Key Takeaway

The cases published by people building products alone with AI share a structure. The human sits at the top and keeps direction, product decisions, approval and customer relationships; below that, a coordinator agent splits the work and hands it to role agents (product, build, verification, marketing and support). Official docs from Anthropic, OpenAI and CrewAI all advise starting with one agent and adding roles and hierarchy only when needed. The solo-founder cases, however, are all self-reported, so independently verified evidence is still thin.

More and more posts claim to “run a company with AI agents.” This post uses only three published solo-founder write-ups and official agent-framework docs to summarize how one person sets up AI roles and agent teams, and in what stages they run the work of building a product. No cases are invented, and where evidence is thin, the post says so.

What does it mean for a solo founder to build an AI ‘organization’?

One-line answer: giving several agents roles, reporting lines and permissions like a human org, while the person keeps only decisions and approvals.

  1. The cases below all say they built an “organization,” not a “pile of scripts.” In I Built a Company With 23 Employees, Jeremy Knox writes that scripts had no authority structure, no way to check each other and no sense of who owns which decision, and that an org chart is what produced accountability.
  2. Technically, this belongs to the same family as the orchestrator-workers pattern in Anthropic’s Building effective agents (a central LLM breaks down tasks, delegates them to worker LLMs and synthesizes the results) and the manager/specialist setups in OpenAI’s docs. The “company” metaphor adds role names and reporting lines on top of that structure.

What org charts do real solo-founder cases use?

One-line answer: all three use “one human + a coordinator agent + per-department agents,” with different sizes and tools.

  1. V4D (Justin Paul): in I Built an Entire Company Out of AI Agents – Part 1, he describes building 9 departments and 34 agents around his own product: executive (a Chief of Staff agent that sets OKRs and coordinates across departments), product, marketing, sales, support, design, testing, project management and HR. Each department gets a channel in a self-hosted chat app (Mattermost) so agents can read each other’s work. He says it started with one script, one API call and one channel. He calls the project a hobby and admits output quality varies.
  2. GenBrain AI (Moshe Beeri): in How One Founder Built a Company with AI Agents, he writes that he brought up CEO and CTO agents first to establish coordination patterns like task assignment and review, then added backend, security and DevOps, then frontend and marketing agents. The CTO agent reviewed PRs and he reviewed the CTO’s reviews to build trust. The marketing agent’s early output was too generic; the fix was not better prompts but access to internal docs and real metrics. Keep in mind this post is on the blog of a company (agent.ceo) that sells an agent-orchestration platform.
  3. Tesseract Labs (Jeremy Knox): in the same post, he describes a layered structure: a CEO agent, a Chief of Staff and C-suite below it, directors below them, and an “owner” agent for each app at the bottom. Engineering is split into teams such as a feature team (backend, frontend, QA), a quality team and a security team, and a message broker that every agent goes through enforces per-agent authority ceilings and a staged kill switch.

How do the official docs say to split roles and agent teams?

One-line answer: give each role a narrow, clear job, decide whether a manager owns the final answer or a specialist takes over, and start with the simplest structure.

Common shape of a one-person AI org: founder, coordinator agent, role agents

  1. Defining roles: CrewAI’s Crafting Effective Agents defines an agent by role, goal and backstory, and advises specific roles such as “Technical Documentation Specialist” instead of “Writer.” The same guide lists “premature use of hierarchical structures” as a common mistake: start with sequential processes and move to hierarchy only when the workflow truly requires it. In a hierarchical process, a manager agent delegates tasks and validates outcomes (Hierarchical Process).
  2. Who owns the final answer: OpenAI’s Orchestration and handoffs doc distinguishes handoffs, where a specialist takes over the conversation, from agents as tools, where a manager stays in control and calls specialists as bounded capabilities. It says to “start with one agent whenever you can,” to add specialists only when they materially improve capability or policy isolation, prompt clarity or trace legibility, and to give each specialist a narrow job.
  3. Delegating work: Anthropic’s How we built our multi-agent research system says that when the lead agent hands subtasks to subagents, each needs an objective, an output format, guidance on tools and sources, and clear task boundaries; without them, agents duplicate work or leave gaps.
  4. Cost and limits: the same post reports that in Anthropic’s data agents used about 4× more tokens than chat, and multi-agent systems about 15× more, and that domains where all agents must share the same context or that involve many inter-agent dependencies (including most coding tasks) are not a good fit for multi-agent systems today. For a solo operator, more agents means more cost.

In what stages should you grow the organization?

One-line answer: start with one, define roles, add a coordinator and a first worker, put verification and permission controls in place, and add only roles that prove useful.

  1. ① Start with one agent: Anthropic says to find the simplest solution and add complexity only when needed (Building effective agents), and OpenAI’s docs say the same. V4D also started from one script and one channel.
  2. ② Define roles: write down each role, goal and narrow scope (CrewAI, OpenAI).
  3. ③ Coordinator + first worker: the GenBrain post says “start with two agents, not seven,” stabilizing the coordination layer (CEO and CTO) before adding workers. Following CrewAI’s advice, a sequential flow is simplest at first.
  4. ④ Add verification: Knox runs quality and security teams before anything ships, and GenBrain had a human re-review the CTO agent’s reviews. The O’Reilly Radar article cites Anthropic’s long-running harness work as finding that separating generation and evaluation into distinct agents beats self-evaluation, because agents tend to grade their own work too generously.
  5. ⑤ Permissions and stop switch: Knox uses per-agent authority ceilings and a staged kill switch; in V4D, only the support responder agent has write access to answer customer tickets.
  6. ⑥ Expand only when needed: putting OpenAI’s “add specialists only when they materially help” together with Anthropic’s cost warning, add roles only as far as their value is confirmed.

How do you run the actual product-building work in stages?

One-line answer: set up the environment and a feature list in the first session, then implement, verify and commit one feature per session while keeping a progress record.

Six stages for growing an agent organization

  1. Anthropic’s Effective harnesses for long-running agents splits long development work into two roles. On the first run, an initializer agent creates a run script, a progress file, an initial git commit, and a feature list file based on the spec; in every later session, a coding agent reads the progress file and feature list and picks a single feature to work on.
  2. Per the same post, limiting work to one feature at a time was critical to curbing the agent’s tendency to do too much at once, and having it commit with descriptive messages and write progress summaries let the next session pick up without guessing. For a solo founder with several agents, having every agent read and write the same progress record means you don’t have to relay “who did what” by hand.
  3. The human’s place is review and approval. Knox writes that he reviews the PRs the feature team produces, and GenBrain also kept a human re-review step.

What should the human keep doing personally?

One-line answer: direction, product decisions, customer relationships, and approval of hard-to-undo actions.

  1. Knox sums up his job as “I set intent. I review what matters. I make product decisions,” and writes that agents can’t make calls such as pricing or market expansion for him.
  2. The GenBrain post says “do not over-automate yourself”: judgment, vision and customer relationships can’t be automated, so keep yourself in the loop for what matters. V4D, too, has a human review the output every day.

Where is the evidence thin?

One-line answer: all the solo-founder cases are self-reported, and I found nothing that independently confirms their results or longevity.

  1. All three cases are blog posts by the founders themselves, and one is on the blog of a company that sells a related platform. Structural details such as agent counts are repeated as written, but performance figures such as output volume, cost and time can’t be verified, so this post doesn’t repeat them.
  2. All three were written in 2026, so it’s too early to know whether these structures hold up over time or lead to business results such as revenue. The V4D author calls his project a hobby.
  3. On the other hand, “start simple,” “make roles and task boundaries explicit,” and “multi-agent is expensive” are points that the Anthropic, OpenAI and CrewAI docs share, so they stand on firmer ground. The stage list in this post is my own summary of that common ground with the cases layered on top.

Which sources were used?