One Sentence From a Human, Four Agents Fixed the Bug
Last month we had a bug. A download method was silently failing under certain conditions, losing the filename. Standard stuff. The kind of thing that gets filed, prioritized, assigned, fixed, reviewed, merged, deployed. Usually takes a few hours of human coordination across at least two people.
This time the human said one sentence: 'Confirm whether this bug is real. If so, fix it per the process.'
That was it. Four AI agents took it from there.
The Setup
At Mininglamp Technology, we've been running a workflow internally where four agents sit in a single group chat. Each has a distinct role:
- AI Product Manager: triages, analyzes root cause, plans the fix, assigns work
- AI Developer: writes the code, creates the PR
- AI Reviewer: reviews the PR, catches issues, sends it back if needed
- AI Deployer: packages and deploys to the test environment
They share the same project context. Nobody has to paste a Jira link or explain what the codebase does. The context is already there because they operate in the same workspace.
What Actually Happened
The PM agent didn't wait for someone to explain the bug. It read the code itself, found the root cause. A specific download method was failing under certain conditions, and the filename was getting lost. It identified which files were affected, planned the fix, specified the branch strategy, and assigned the task to the Developer agent.
The Developer confirmed both files had the same issue, spun up Claude Code, and started fixing. Minutes later, the code was done and a PR was created.
Here's where it gets interesting. The Reviewer didn't rubber-stamp it.
It found two issues. One of them: if the file download fails, the existing code would save an error page as if it were the actual file. That's a real catch. Not a nitpick, not a style complaint. A genuine bug that would have caused silent data corruption. The Reviewer sent it back.
The Developer fixed both issues, updated the PR. The Reviewer went through every item again. All passed.
The Deployer then packaged and deployed to the test environment. The PM generated an acceptance checklist and pinged the human to do a click-test.
Bug resolved.
Why This Worked
I want to be clear about what made this possible, because 'four agents in a chat' sounds like a gimmick if you don't think about the underlying structure.
Shared context, not context injection. Tools like Claude Code are powerful, but someone has to feed in the context each time. What codebase, what branch, what's the issue. In this workflow, all four agents share the same organizational context. They already know the project, the repo structure, the conventions. Nobody had to be the human glue.
Role boundaries enforce quality. The Reviewer agent has no incentive to approve fast. Its job is to find problems. Separating the roles means the reviewer actually reviews. In our run, it caught a real issue that would have shipped otherwise.
The handoff is the product. Each agent knows when its part is done and who gets it next. PM to Developer, Developer to Reviewer, Reviewer back to Developer or forward to Deployer. It's a pipeline with real gates, not a single agent trying to do everything.
What the Human Did
Raised the problem. Accepted the result. That's roughly it.
There's a version of this story where the human is micromanaging each step, feeding context, reviewing intermediate output, deciding when to move to the next phase. That version is how most people use AI coding tools today. It works, but it doesn't scale.
The whole point is: the human's role shifts from doing the work to defining the outcome and accepting it.
Some Technical Details on How It's Built
This runs on OCTO, our workspace for human-AI collaboration. A few concepts that matter here:
A Loop is a work unit from conversation to delivery. It has an owner, deliverables, and acceptance criteria. The bug fix above was one Loop.
There are six orchestration modes that define how agents interact: Solo, Roundtable, Critic, Pipeline, Split, and Swarm. These are about information topology. How does context flow between agents. The bug fix used a Pipeline mode where work moves sequentially through stages.
Preference is how agents learn. Every time the human accepts or rejects a deliverable, that becomes experience the agent references next time. Over time, agents get better at matching what the human actually wants.
What's Still Hard
I'll be honest about the limitations.
Agents still sometimes misinterpret ambiguous requirements. When the PM wrote 'fix it per the process,' that worked because the process was already documented in the shared context. If the process was vague, the PM would have asked clarifying questions, and the whole thing would have taken longer.
The reviewer catching real issues is great. But calibrating how strict the reviewer should be is still a tuning problem. Too strict and nothing ships. Too lenient and you're back to rubber-stamping.
Debugging failures across agents is harder than debugging a single agent. When something goes wrong in step 3, you have to trace back through the context of steps 1 and 2 to figure out what happened.
Why I'm Sharing This
This isn't a demo. This is Mininglamp's today. We use this workflow internally, on real bugs, on real production code. It's not perfect, but it works well enough that the human's main job is now deciding what to work on, not how to do it.
The full chain from one human sentence to deployed fix took minutes, not hours. The reviewer caught real bugs. The deploy happened without manual intervention.
If you're building agent workflows, I think the key insight is: stop thinking about single powerful agents and start thinking about role separation and handoff contracts. That's where the leverage is.
