How we built the output of a $100k team for $1k

Usually the conversation falls into one of two camps: a fake demo, or someone saying AI cannot replace employees as if the only benchmark that matters is whether a model can become a fully formed adult with taste, judgment, and payroll paperwork.

That is obviously the wrong frame. We tested something narrower and much more useful. Instead of hiring a team to do repetitive operational work, we set up a system of subagents. Each one had a narrow job, clear tools, and a defined output format.

One handled research. Another structured information. Another drafted. Another reviewed. Another pushed things into the right place. OpenClaw sat in the stack where legal and document-heavy work needed to happen.

The result was not AGI. It was better than that, honestly. It was useful.

We did not build one all-knowing agent. We built a small system of specialised subagents with tight scopes, shared context, and review loops.

That matters because most AI workflow failures come from giving one model too much responsibility, too much context, and not enough structure. The real unlock was orchestration.

A lot of company work is fake complexity. Not hard complexity. Just work that exists because information is scattered, someone has to move it around, someone has to rewrite it, someone has to check it, and someone has to push it into the next system.

That is exactly the kind of thing AI is good at, provided you stop pretending one giant prompt will solve it.

If you ask a single agent to do research, reasoning, drafting, QA, compliance checks, and system actions all at once, it usually degrades fast. It misses edge cases, loses context, and starts confidently making things up. So instead of building one employee, we built a pipeline.

The architecture was pretty simple in principle. A planner agent breaks the job into steps. Specialist subagents execute narrow tasks. A reviewer agent checks outputs against rules. Tool-enabled agents fetch, transform, or file information. OpenClaw sits in the stack where legal and document-heavy work needs to happen. A human stays in the loop for approvals and high-leverage decisions.

That is the whole idea. Not intelligence as theatre. Intelligence as workflow design.

Each subagent has one job and is judged on one thing. That makes prompt design easier, failure modes more obvious, and quality much more consistent.

Instead of asking one model to write a great article using our brand voice, source material, and compliance constraints all in one shot, we split the workflow into smaller jobs.

One agent researches. One extracts claims worth using. One builds an outline. One drafts. One reviews for factual drift. One checks tone. One flags anything risky. Then the final output is either published or handed to a human for approval.

Once you do that, the system stops feeling like a chatbot and starts feeling like infrastructure.

The savings did not come from raw model intelligence. They came from removing coordination overhead.

Hiring humans for this kind of work is expensive in ways people underestimate. Not just salaries, but management, training, handoffs, QA, context switching, and the general drag of getting five people to care about a process as much as the founder does.

A good subagent does not get tired, does not forget the checklist, and does not need a meeting to explain why the CRM update still has not been done. If you narrow the scope enough, the output quality becomes surprisingly high relative to cost.

OpenClaw is useful anywhere the workflow touches contracts, legal docs, clause extraction, compliance checks, or structured document review.

That category of work is perfect for agent systems because it is high-volume, rules-heavy, and usually bottlenecked by people wasting time reading the same patterns over and over again.

You still want human review on anything material. Obviously. But if the system can do first-pass analysis, pull out risk areas, structure the contents, and tee up what actually matters, you have already compressed a big chunk of the workload.

The common mistake is building agent systems too broadly. People want a single autonomous worker that can do everything. In practice, that usually gives you an expensive stochastic intern with too much access.

The better pattern is much more boring: narrow task definitions, explicit tool access, shared memory only where needed, structured outputs, reviewer loops, and human approval at the right checkpoints.

This only works if the workflow is decomposable. If the job depends on deep taste, novel strategy, delicate stakeholder management, or genuine accountability, you still need humans. Preferably good ones.

Agents are also brittle if the tools are unreliable, the prompts are vague, or the success criteria are fuzzy. A badly designed agent stack can absolutely create more work than it saves.

Most of the value is in the setup. The prompts matter less than people think. The real leverage is in process design, context routing, validation, and knowing where not to automate.

AI does not replace great teams. But a small number of good operators, using the right agent stack, can now produce an absurd amount of output relative to cost.

That changes the shape of a modern company. You need fewer people doing repetitive coordination work and more people who can design systems, define quality, and point automation at real bottlenecks.

The models will improve. Tooling will improve. Costs will keep falling. But even right now, if you structure it properly, you can get the output of a very expensive team for something much closer to software spend.