Managing four concurrent coding agents is where my productivity

I’ve been trying to scale my engineering output by running multiple coding agents in parallel, but I hit a massive bottleneck almost immediately. As someone who actually cares about code quality, I can't just "set and forget" an LLM agent. If I don't manually supervise the session, the agent eventually loses the thread, hallucinates a file structure that doesn't exist, or ignores a critical piece of documentation I provided ten prompts ago.

The problem isn't the LLM itself; it's the "stale context" issue. You give an agent a task, it starts working, and by the third or fourth step, the context it's operating on is already outdated because of the changes it just made or the new rules it should be following. I found myself constantly clicking through different terminal sessions just to make sure an agent wasn't about to commit something disastrous.

To solve this, I've been experimenting with a concept called Meetless Agent (MLA), which acts as an active monitor rather than just a passive prompt wrapper. Instead of the agent being responsible for its own context management (which it's notoriously bad at), this layer sits on top of the workflow to act as a real-time source of truth.

Here is how this specific AI workflow actually functions:

• Context Reconciliation: It doesn't just dump documentation into the prompt. It continuously reconciles the agent's output, the decisions it's making, and the tagged documentation to ensure the agent is always working with the most recent version of the "truth."
• Rule Injection: You can register specific repo rules (e.g., "always use TypeScript interfaces instead of types" or "never modify the /auth directory"). If the agent's planned action triggers one of these rules, the monitor injects that rule into the context immediately.
• Task Monitoring: It observes the agent's actions in real-time to supply up-to-date context without the human needing to manually intervene every two minutes.

The results from my initial benchmarks are actually pretty significant for anyone looking into a professional AI workflow. By using an active monitor to manage context, I'm seeing higher accuracy and, more importantly, lower token consumption. Because the agent isn't looping through errors caused by bad context, it finishes tasks faster.

I'm treating this as a deep dive into how we manage "state" in an agentic world. The long-term goal isn't just for coding, but for a broader deployment where an AI layer maintains a source of truth across Slack, Jira, and Confluence. Imagine a scenario where a decision made in a Slack thread automatically updates the context for a coding agent working on a related Jira ticket.

If you want to see how this is implemented or try it out yourself, the coding agent connector is open source:

https://github.com/Meetless/mla

For the more data-driven folks, there is some research on the stale context problem here:

https://research.meetless.ai/stale-context/