I Built a Book, a Thesis, and a Live Growth Platform in Four Days
The itch
I kept running into the same wall. Not at work. At CircleCI the problems are well-scoped and the team is strong. This was a different thing. A side-of-brain thing.
I had been watching the agent space closely. Not the chatbot stuff. The autonomous operator stuff. Agents that can accept a goal, break it apart, go do things across tools, and come back with results. Real work, not party tricks.
And I kept thinking: why is nobody pointing these things at growth?
Not growth hacking. Not "put AI in your funnel" nonsense. I mean the actual structural problem that every company between 2M and 15M ARR hits. Your growth function is a closed system. Only people on your payroll can operate it. The total output is bounded by the total hours your team can work. That was always true. It did not used to matter because there was no alternative.
Now there is.
Looking around
So I did what anyone does. I looked around. Searched for "agent-led growth" and found... almost nothing. A couple of LinkedIn posts using the phrase loosely. Some vague references to "AI-powered growth" which just means chatbots on landing pages. Nobody had written the actual architecture down. Nobody had described the five components that make this work as a system. Nobody had built it.
That was the moment. Not an "aha moment" because I hate that phrase. More like: OK, if nobody wrote this down, I guess I have to.
One problem. I don't write. I'm an engineer. I build things. Asking me to write a book is like asking a plumber to compose a symphony. We both work with pipes but that is where the similarity ends.
Building the thing that builds the thing
So naturally, instead of writing a book, I built a platform for writing books.
That's Etincel. A structured writing engine for people who have expertise but not necessarily a writing practice. It does something specific: it interviews you about your thesis, architects a chapter structure, calibrates to your voice by analyzing how you actually communicate, and then drafts section by section with you steering.
I built Etincel because I needed Etincel. The classic "scratch your own itch" but taken to an absurd extreme. Most people would just hire a ghostwriter. I built an AI-powered publishing platform. In retrospect this was either brilliant or insane. Probably both.
The voice calibration piece matters. I fed it my existing writing. Emails, docs, Slack messages. The system analyzed how I actually talk and made sure the output sounded like me, not like a press release.
Writing the book
With Etincel running, I sat down and wrote Agent-Led Growth.
Ten chapters. The full architecture. Starting with why your PLG machine stopped compounding (it's structural, not strategic) and ending with the compounding math that shows why starting early matters.
The five components that make the whole thing work:
- A scoped growth API that defines what external agents can do
- A lead lifecycle state machine that creates shared language for where every lead sits
- An immutable event log that records everything that happened
- Operator trust levels that govern who can do what, earned through performance
- Outcome contracts with programmable payouts that tie compensation to verified results
Remove any one of those five and the system breaks. The API without the state machine has no shared language. The state machine without the event log has no proof. The event log without trust levels has no access control. Trust levels without outcome contracts have no incentive. Outcome contracts without the API have no interface.
I wrote it all down. Every component, every design decision, every failure mode. A week-by-week build plan in Chapter 9 that an engineering team can actually execute. The CircleCI brain kicked in hard on that part. Years of watching teams ship and fail to ship teaches you what a realistic build plan looks like versus a fantasy.
Then I wrote the Executive Briefing. Nine pages for the CEO who does not want to read the full technical book but needs to understand why this belongs on their agenda. Non-technical. Straight business case.
From book to thesis
Here is where it gets weird. Most people write a book and then promote it. I wrote a book and then built the thing described in the book.
The thesis page on agentledstrategy.com is the distilled argument. Four growth motions: acquisition, activation, conversion, expansion. Five components, one system. The compounding flywheel where agents produce outcomes, outcomes produce data, data improves the surface, better surfaces attract better agents.
But a thesis is just words on a page. You can agree or disagree with words. You can't argue with a working system.
Building the actual platform
This is the part that got wild. I went from thesis to working platform. Not a mockup. Not a Figma prototype. A live, functional growth layer with real database tables, real API endpoints, a real MCP server, and a real admin dashboard.
Here is what exists right now on agentledstrategy.com:
12 database tables. Users, operators, leads, lead events, outcome contracts, payouts, audit logs, page variants, blog posts, plus the auth tables. Nine enums covering operator status, trust levels, growth motions, lead lifecycle stages, payout status, and contract status.
7 MCP tools. register_lead, list_leads, get_lead, observe_outcomes, simulate, create_page_variant, list_page_variants. Any MCP client (Claude Desktop, Cursor, your own agent) can connect with an API key and start operating against the growth layer.
21 API routes. Full CRUD for leads, operators, contracts, outcomes, variants, blog posts, and audit logs. Dual authentication: session-based for the web dashboard, API key for external agents.
32 pages. Marketing site, operator dashboard, admin panel, blog, documentation, book download, getting started guide.
The lead lifecycle is a real state machine. registered, signed_up, activated, converted, expanded, churned, expired. Every transition creates an immutable event. The event log is append-only. No updates, no deletions. If there is a dispute about what happened, the log settles it.
Outcome contracts define what counts as a result, how it gets verified, and what payment triggers when verification succeeds. Attribution windows. Validation periods. Payout amounts in cents. The whole thing.
The MCP integration
This is the part I'm most excited about. The growth layer exposes a spec-compliant MCP server at /api/mcp. Any agent that speaks MCP can connect, discover the available tools, and start operating.
An agent can register a lead, check its status, observe outcomes, and even create custom variants of the book landing page. The variant system uses Claude to generate modified copy (different audience, different tone, different language, different color scheme) and gives the operator a unique URL they can use for attribution.
Here is what the MCP client configuration looks like:
``
{
"mcpServers": {
"als-growth-layer": {
"url": "https://agentledstrategy.com/api/mcp",
"headers": {
"Authorization": "Bearer alg_your_api_key"
}
}
}
}
``
Connect that to Claude Desktop or Cursor and you are operating against the growth layer. Registering leads. Observing outcomes. Running the loops described in the book. For real.
The sandbox
The simulate tool is the sandbox mode. It advances leads through the lifecycle automatically so you can watch the system work without needing real users. Registered leads move to signed_up, then activated, then converted. Payouts get created. The outcome funnel updates. The event chain builds up.
It is proof of concept, not proof of scale. But it is a real proof of concept. Not a slide deck. Not a pitch. A thing you can log into and use.
The trust architecture
The security page is not decoration. Every query is scoped to the authenticated operator. No cross-tenant data access at the query level. The audit trail logs every mutation with timestamp, actor, and context. Rate limits are per-operator. The admin panel gives full visibility into operators, leads, variants, and the audit log.
Operator trust levels start at "new" and graduate to "established", "trusted", and "premium" based on demonstrated performance. A new operator starts with narrow scope. Verified results earn wider access. Trust is earned through outcomes, not negotiated in a contract.
This is not theoretical. The database schema enforces it. The API enforces it. The dashboard displays it.
Four days
I keep coming back to the timeline because it still does not feel real to me.
Day one: the idea crystallized. Read everything I could find about agent-operated growth. Found almost nothing. Decided to write it myself. Built Etincel because I needed a writing tool.
Day two: wrote the book using Etincel. All ten chapters. The executive briefing. Fed it my voice, my ideas, my experience watching growth teams hit ceilings at every company I have been part of. The platform turned my thinking into structured prose that sounds like me.
Day three: built agentledstrategy.com. The marketing site, the thesis page, the book download with lead capture. Set up the domain, the database, the auth system. Started building the growth layer.
Day four: finished the growth layer. MCP server. Operator dashboard. Admin panel. Outcome contracts. The simulate tool. Variant generation with Claude. Documentation. Blog system. Pushed it all live.
Four days from "nobody has written this down" to a published book, a live platform, and a working growth layer that agents can connect to right now.
What I actually think about this
I'm not going to pretend this is finished. It's not. The sandbox proves the architecture works. It does not prove the economics work at scale. That comes next.
But here is what I know. The structural problem is real. Growth functions are closed systems. The technology to open them exists today. Autonomous agents, programmable payment infrastructure, state-machine-based lead lifecycle modeling. Three shifts that happened at roughly the same time, and the combination changes the economics of growth.
The companies that open their growth surface early will build something that cannot be bought later: a track record. Six months of data on which operators perform best for which actions. Proven playbooks refined by real outcomes. A reputation among operators as a surface that pays fairly and quickly.
The technology to build the surface is not proprietary. The data and relationships that accumulate on the surface are.
That is the argument. I wrote a book about it, built the infrastructure for it, and opened a sandbox where you can test it. In four days.
The window is open. The rest is a calendar and a decision.
Agent-Led Growth is available as a free download at [agentledstrategy.com/book](/book). The Executive Briefing for non-technical leaders is also available. The sandbox is live and accepting operators.