A single Claude Code agent can finish a bounded task inside one session without much fuss. The real trouble starts when the work spans days, multiple sessions, and sometimes multiple agents handing work back and forth. Objectives shift partway through. Evidence gathered early goes stale. Tasks go unclaimed because nobody, human or agent, is tracking who owns what. A community write-up on a local control-plane pattern, built around an open-source project called LoopX, names this gap precisely, and it names a structure worth borrowing regardless of whether a business ever touches LoopX itself.
The gap chat memory and timers don't cover
Chat memory and simple scheduling timers do not govern any of this. A conversation history tells an agent what was said. It does not tell the next session, possibly run by a different person the following morning, what the actual objective still is, what evidence has already been gathered and is still valid, who owns the next step, or whether the last attempt hit a dead end that should not be retried. That is a durable state problem, not a memory problem, and it sits outside what a single Claude Code session is designed to track on its own.
The pattern's answer is a control plane that sits outside the agent runtime entirely. It does not replace Claude Code or reason about the work itself. Each agent turn handles one bounded slice of work; the control plane holds the objective, gates, todos, scope, evidence, quota, and hand-off state between turns, and decides whether the next tick should continue, wait, or stop and escalate to a human.
Why this matters more once multiple agents are involved
The multi-agent case is where this stops being a nice-to-have. Multiple agents claiming different tasks through explicit ownership, lease, and hand-off state prevents the two failure modes that show up as soon as more than one agent touches the same body of work: duplicate edits from two agents working the same problem unaware of each other, and infinite loops from an agent retrying a task another agent already attempted and abandoned for a good reason.
Objective and scope, stored outside the chat session, so a fresh session or a different person picking up the work knows exactly what is still in play.
Ownership and lease state, so two agents don't silently duplicate the same edit or fight over the same file.
Evidence with an expiry, so an agent doesn't act on a finding that was true three days ago but has since changed.
A quota and stop-condition layer, so a scheduler burning through API calls has an explicit signal to pause and ask a human rather than looping indefinitely.
The write-up describes the resulting system as something close to an executable kanban board for long-running agent work: recoverable if a session dies mid-task, auditable after the fact, and structured so the next agent or the next person can pick it up cleanly rather than starting from a half-finished chat transcript.
What this looks like as a scoped build, not a product pitch
This is not a pitch for LoopX specifically. It is a pattern worth building for a client running genuinely long Claude Code work, multi-day builds, overnight research agents, anything that spans more than one session or more than one person. A lightweight control-plane wrapper around Claude Code, tracking objective, evidence, ownership and next-step in a durable store outside the chat session, is a scoped build an AU engineering team can commission rather than adopt wholesale from an open-source project with its own roadmap and priorities.
The hard part of long-running agents was never really keeping the model running for longer. It is whether the objective, the evidence, the ownership, and the next step all survive intact after each turn ends, which is exactly the gap between a Claude Code demo that looks impressive for twenty minutes and a Claude Code system a business can actually rely on unattended overnight.
A concrete failure this pattern prevents
Picture an overnight research agent tasked with hill-climbing a test suite across a large codebase. Without durable state, a session that dies at 2am, whether from a network blip or a quota limit, loses everything: which approaches were already tried and failed, which files are mid-edit, and which findings are still valid. The next morning's session starts cold, possibly re-attempting the exact dead end from the night before. A control plane holding that state outside the chat session turns a lost session into a resumable one, which is the entire difference between an agent that saves a business real engineering hours overnight and one that just burns API quota retracing its own steps.
The Automata AI take
We build this exact pattern, a durable state layer sitting outside the chat session, for Sydney and Melbourne clients running multi-day Claude Code work where losing context between sessions is not an acceptable failure mode. A scoped control-plane wrapper for a single team's workflow typically runs A$4,000 to A$9,000, depending on how many agents and hand-off points are involved.
Book a brainstorm if your team's long-running Claude Code work keeps losing context between sessions.
