Production failures are mainly limited by developer-loop speed, because models, GPUs, and frameworks can be replaced while engineering attention remains scarce.
2
Sub-agents can work in parallel worktrees, use organization-specific skills, and handle tasks from QA tickets through testing, deployment, and reporting.
3
Automation should remove the developer from routine work while keeping a human at the start and end as the verifier.
Summary
Ramana Siddanth Emani argues that production finance agents fail less because of model capability than because developers cannot move through the bug-fixing loop fast enough. He describes a harness with sub-agents working in isolated git worktrees, organization-specific skills, connections to tools such as Jira, GitHub, logging systems, and authentication gateways, and a small interface for orchestration. A task can begin with a QA ticket, then proceed through trace collection, root-cause analysis, test-driven development, implementation, end-to-end tests, pull requests, builds, deployments, and staging checks. Emani says humans should supervise the start and verify the result at the end, while agents handle the intermediate steps. He then describes feeding production failures back into the harness so it can find and remove its own bottlenecks. In finance, accountability still matters, so autonomy does not remove the need for a human verifier.
Developer-loop speed is the bottleneck after an agent reaches production
Emani says demos are easy to ship, but production exposes bugs because an agent has not seen the customer's future data. He rejects the idea that the lasting answer is always a better model, faster GPUs, or a new framework. Those options can change within months or a year, while developers still spend their days handling the work around each production issue. His answer is to improve developer-loop velocity. The engineering team needs to automate the repeated steps that turn a production failure into a tested and deployed fix.
Parallel worktrees let sub-agents handle independent tasks
The first primitive is the sub-agent. Emani suggests running an army of agents at once, with each one working in an isolated git worktree. He describes worktrees as separate folders where an agent can write code without interfering with another agent. Independent tasks can then proceed in parallel instead of competing for one checkout or waiting in a queue. He gives the example that a MacBook with 48 GB of RAM could run 50 active worktrees, with separate agents handling different pieces of work.
Skills encode the organization's preferred way to fix problems
Emani calls skills the organization's "secret recipes." They tell agents which workflows and patterns to use when solving a production bug. The point is to give the agent more than access to code and external tools. It should also receive the practices the team expects it to follow. He places these skills alongside sub-agents and worktrees as one of the basic parts of an automated developer harness. Agents may also connect to third-party systems through MCP tools, while customer data can remain in the systems where it already lives.
A QA ticket can drive the whole path from diagnosis to staging
Emani's example starts with bug tickets reported by QA, including Jira tickets. An agent parses the requirements, investigates the root cause, collects traces and logs, and works in its own worktree. It then writes tests, implements the fix, runs local end-to-end tests, creates a pull request, and sends it for review. After the merge, the agent builds a Docker image, deploys it to development, tests it, builds and deploys to staging, and tells QA that the change is ready. The agent handles the middle of this sequence, while the human checks the initial task and the final staged result.
A single interface reduces the attention spent orchestrating agents
Emani describes a small macOS widget that brings the main parts of the developer workflow together. It can show project dashboards, Kubernetes services and pods, examples, system logs, Jira tickets, GitHub pull requests, and an active coding session. The purpose is to avoid opening many windows and repeatedly switching between them. He connects this to the physical habit of turning between two or three monitors while coordinating agents. A compact interface lets the developer supervise more of the workflow without spending attention on window management.
Finance requires accountability even when agents review other agents
At Auditoria AI, the work involves finance, regulation, and compliance. Emani contrasts an ordinary process, where a human auditor reviews the work and a controller signs off for compliance, with a system in which agents review other agents. He asks where accountability would sit if an automated process caused a production failure. The finance setting changes the meaning of moving quickly, so simply adding more autonomous agents does not solve the governance problem. Human responsibility remains part of the design.
Production failures can become input for improving the harness
Emani proposes using failures from the production loop to improve the loop itself. After letting the automated process run for a day or two and solve several bug tickets, the developer can ask the agent to list the bottlenecks it encountered. The team then removes those bottlenecks over time. He imagines that after a month, a developer could write one sentence such as "fix this bug for me," and the system would retrieve database information, logs, traces, and tickets before moving the change through the QA pipeline. Goals and loops can also run against a data discrepancy while the developer is away from the laptop.
Customer usage patterns can suggest future product changes
Emani describes a background process he calls "dreaming." It collects customer sessions, compresses repeated usage patterns into data points, and uses them to improve the system. His example is customers using the production software in similar ways and encountering similar problems. Those recurring patterns can become input for upgrades or new features. This extends the harness beyond fixing tickets that humans have already written. The system can observe how customers use the product and identify repeated work or problems for the team to address.
Autonomy should increase throughput while a human verifies the result
Emani's final design keeps a human involved as a verifier rather than making human attention the limit on throughput. Agents can work in parallel, follow organizational skills, connect to logging and authentication systems, and run toward goals inside loops. The developer decides which work should be handed off and checks what comes back. In finance, that final check matters because the work has compliance and accountability requirements. The proposed shift is away from manually performing every intermediate step and toward reviewing the work at the points where human judgment is needed.
"I would say the human is only required at steps 1 and 9 because the in-between steps, the agent can do a lot better work."06:27
Who should watch
You are building an AI product that works in demos but accumulates bugs and manual release work when customers arrive.
Your team has QA tickets, logs, traces, pull requests, and deployment steps spread across separate tools and wants agents to coordinate the routine path.
You work on finance software or another regulated system and need a way to increase automation without removing human accountability.
