The 10-Person Billion-Dollar Company: Altman's Prediction and a Free Toolchain
Sam Altman says 10-person billion-dollar companies are coming soon. The free toolchain is already complete; you just need to click approve at the final step.
Sam Altman said something in a 22-second video that will take many people a while to digest: "We are going to see 10-person billion-dollar companies pretty soon. If I were 22 right now, I would feel like the luckiest kid in history."
10-person billion-dollar companies are coming soon. If he were 22 now, he would feel like the luckiest kid in history.
When Facebook bought Instagram for $1 billion in 2012, Instagram had 13 people. Altman is not talking about selling a company and cashing out; he is talking about 10 people directly building a company to a $1 billion valuation. The company form he describes is: a few founders plus an agent team handling everything else. By agent here, he means an AI program that can complete tasks independently, not a chatbot.
The technical path is already clear: ChatGPT → Claude Code → Agents SDK → Loops → Graphs → a 10-person agent company.
The accompanying toolchain is also entirely free. From your first agent to a work team that can actually get things done, here are 11 links:
- Choosing AI's first job: an official OpenAI PDF on how to identify and scale AI use cases. http://cdn.openai.com/business-guides-and-resources/identifying-and-scaling-ai-use-cases.pdf
- Five forms of agent systems: Anthropic's engineering documentation; Anthropic writes about agents in a very practical way. http://anthropic.com/engineering/building-effective-agents
- Run your first agent in the terminal: Claude Code quick start. http://code.claude.com/docs/en/quickstart
- Codex CLI: OpenAI's open-source coding agent, runs locally, installable via npm and brew. http://github.com/openai/codex

- Handing off tasks between agents: OpenAI Agents Python SDK. http://github.com/openai/openai-agents-python
- Replicate an entire customer support team: OpenAI's customer support agent demo. http://github.com/openai/openai-cs-agents-demo
- Loop until tests pass: a cookbook example using Codex for iterative repair. http://developers.openai.com/cookbook/examples/codex/build_iterative_repair_loops_with_codex
- Karpathy's experiment loop: autoresearch, turning the AI research process into an automated loop. http://github.com/karpathy/autoresearch
- A graph that waits for your approval: LangGraph, which lets agent workflows stop at key nodes and wait for a human. http://github.com/langchain-ai/langgraph
- Gates before completion: Claude Code hooks. http://code.claude.com/docs/en/hooks
- Detect when an agent gets worse: promptfoo, for regression testing agent outputs. http://github.com/promptfoo/promptfoo
Cost: $0. Open the first link, and you can get an agent running in a weekend.
But most people will get stuck at the same place: once there are many agents, watching them the whole time is more exhausting than doing the work yourself.
An article by Hanako breaks this down. Title: Loops and Graphs: how to stop babysitting agents and only approve the last step. Link: http://x.com/i/article/2091485629452304385
Her core judgment: loops live inside nodes, graphs live between nodes. You don't have to choose; you need both layers.
Loop: make the work of one unit correct
At bottom, a loop has only four parts: produce, check, correct, repeat until green.
The check is everything. If there is nothing that can make the work fail while you leave the room, what you have is not a loop; it is a scheduler.
Almost no one writes the check first. The common approach is to finish the work, add a review at the end, and have another model look at the output. Two optimists nodding at each other.
A real check has to be executable by a program: the test suite exits with code 0, every claim carries a source line, and the diff touches only the files listed in the plan. "The model says it is confident" does not count. "No errors were reported" does not count either. The absence of errors does not mean correctness. A system can confidently repeat the same mistake until the budget runs out, with clean logs the entire time.
Graph: decide which units exist
A loop makes a unit better, but it cannot decide which units should exist, whether the order is right, or which steps don't need to wait. The result can be: a great agent running the wrong three steps, serially, one step waiting for the next. Every step is correct, and the final outcome is both slow and wrong.
A graph is the shape of the work. Nodes are units of work; edges are dependencies. Every error behind unnecessary waiting is treating "then" as a dependency: first summarize the files, then check the weather. The weather does not consume the summary result; there is no edge between them, and a linear script has hard-wired them together. The way to find dependencies: ask "which variable passes from this step to the next?" If you cannot name the variable, that wait is waste.
A graph with no return path is a pipeline; it outputs and forgets. A working graph has two return edges. The correction edge: a gate rejects a unit and sends it back upstream, fixing the current round. The learning edge: an accepted result becomes a constraint passed to the splitter, fixing every future round.
Most people build only the first. The sign is that the system runs fast but never gets smarter.
Another detail worth remembering: return the unit, not the batch. Four slices, one fails, the whole batch goes back, and the three correct ones get rewritten. The rewritten versions are different, but not better, because they were not wrong in the first place. One failure becomes four uncertain results. Return the failed file, not the whole batch.
What should the gate open on? Not confidence, but blast radius. Confidence is the only thing the model can influence. How much it costs to undo a wrong change is a variable the model cannot touch.
Where should the human stand? At the step with the most serious and irreversible consequences. Approve the merge; decide which fixes go live. Not reviewing intermediate outputs. Once a human steps into the graph, they become the slowest node in the graph.
Hanako closes with three sentences:
Measure the path, not just the answer it reaches.
A judgment that does not change the next action is a report.
Any failure that does not become a permanent constraint, you will encounter again.
Most people will keep tuning a loop and call that a system. A few will draw a graph around it and run an entire fleet, not quite understanding why others can't catch up.
发布时间: 2026-11-21 01:39