I have more than one coding-agent subscription. Suppose I hit the limit on one with a bug half fixed and an afternoon left to work. I can open the same branch in another tool. What I’d like to type is “carry on.” What I often have to be ready to explain is what the user wanted, why a perfectly sensible fix was ruled out, which test I trust, and what I meant by done.

That was the question that changed the direction of my exploration. I had started with agent loops. I wanted help going through messages in the morning, deciding what needed my attention, and leaving well-defined work running overnight. Then I tried to picture the morning after. If I open my laptop and find six branches, three finished conversations, and a ticket still marked In progress, what exactly did I automate?

I’m exploring a way to keep the work intelligible from the first conversation about a problem to the decision to release a change. I call the proposed shared layer a control plane. It would let a team assign work, change its direction, inspect what happened, and decide when it can move on. The team would own that record. People could use Claude Code, Cursor, Codex, or a terminal to contribute to the same task. The part I most want to get right is the moment a different person or tool takes over.

Start with what happens in the morning

Consider a plausible morning. A colleague asks in Slack whether yesterday’s fix is live. A customer reports a confusing screen in an email. A ticket mentions the same screen under a different name. There’s a design discussion about it on the calendar. Four entries in a daily digest could be four pieces of work, or four traces of one unresolved decision. Counting the entries tells me very little about my day.

I’d like a morning assistant to bring those traces together and suggest a route. For the colleague, it can look up the release and draft a precise reply. For the customer report, it can preserve the wording and find the existing ticket. If the intended behaviour is clear and reproducible, the issue can go into a coding queue. If two teams disagree about the behaviour, the useful output is a design question for the meeting. An assistant that silently commits us to one interpretation has made tomorrow’s coordination harder.

I already have pieces of this routine in separate tools, including daily briefs, thread triage and a queue for unattended coding. The missing piece in my design is continuity between them. Once a fix ships, the original thread is still waiting. A link from the task back to the conversation gives an assistant enough context to draft the closing reply. I can read it, check that released really means available to that person, and send it. That last mile is part of delivering the change.

This is also how I’d assign permissions. Reading a thread, drafting in my voice, placing work in a queue, opening a pull request, and sending a message on my behalf each carry a different consequence. I’d give the overnight worker a branch, a bounded task, and permission to propose a change. Authority to merge, release, or speak for me would stay with the people who own those decisions. A scheduled run on a machine that has lost access to the queue should leave a visible failure. An empty report would make a broken connection look like a quiet morning.

Give the work a memory of its own

By a “central brain,” I mean that two workers can agree on which task they are doing and find its latest evidence. I don’t need to put everybody’s messages, code, and knowledge in one database. In fact, those things age at different rates.

What I would keep What belongs there When it changes
A task with a stable ID The user’s problem, expected behaviour, dependencies, owner, and link to the original request When someone changes the scope, priority, or owner
A handoff The exact revision, last verified result, a consequential decision, what is uncertain, and the next action At a meaningful checkpoint or when parking the task
A history of events Who claimed the work, which tool ran, what it tested, when it stopped, and links to the resulting evidence A new entry for each meaningful transition
Project knowledge Conventions, design decisions, and repeatable procedures that apply to other tasks When someone establishes that a lesson generalises

Suppose an agent reports a test passing on Monday and someone changes the branch on Tuesday. Monday’s entry is still true. It belongs in the history. The card needs to show that Tuesday’s revision is awaiting verification. A handoff for Tuesday should point the next worker to the changed code. A project guide has no reason to mention Monday at all. Keeping those lifetimes distinct is how I’d avoid growing one enormous memory file that every worker has to read.

A two-tab session problem makes this tangible. In an earlier article I described what should happen when someone has the same application open twice and their session expires. Both tabs should explain the interruption. After the person signs in again, an old message should disappear. In the storage-event design I described there, the tab that writes the shared notification has to update its own screen directly. A note preserving that decision could save another engineer from “simplifying” away the behaviour. Handling session timeouts across browser tabs

The most valuable line in a handoff might be as ordinary as “Sign back in on the first tab, reload the second, and check the banner. I haven’t run that case.” That gives the next agent an action and a boundary on what it may claim. I would checkpoint when a test turns green or an approach is ruled out. A tool that hits a hard limit may never get a final turn to compose its goodbye. If work exists only as uncommitted edits on one machine, the next worker also needs those edits saved somewhere it can reach. A beautiful summary pointing to a missing branch is a failed handoff.

There’s prior work here. Anthropic describes keeping a progress file alongside Git commits so successive sessions can get their bearings. Steve Yegge’s Beads gives agents a shared way to track work and dependencies. What I want to test is the extra condition imposed by an ordinary subscription switch. Can a worker using another provider reproduce what it has been told and identify what remains, with only the artifacts I can take with me? Anthropic’s long-running agent experiments · Introducing Beads

How Claude can leave a message that Codex can act on

The two vendors don’t need accounts in each other’s products. They need permission to read the same task and a way to write a result the next reader can interpret. In the two-tab experiment, Git was the delivery mechanism. A facilitator committed Claude’s files, and Codex received a checkout of that revision. The agents never needed to be online at the same time. For my own use, that’s an appealing definition of communication. I can close both tools, open the repository tomorrow, and read the exchange myself.

For one task on one machine, I’d start with a Markdown file. Here’s how I would represent the first handoff after its revision was saved. This is a condensed example drawn from the run.

TABS-1 · Ready to resume · Claude Code
Revision 04e2ef3
Observed Two tabs showed the sign-in view when the session expired. The expiry browser check passed.
Decision A message from another tab triggers a fresh session check. The receiving tab keeps its own copy of the explanation.
Unverified The expiry message may survive a successful sign-in. Run the return check on this revision.
Product question Should a tab left open during sign-in recover before anybody reloads it?

The job of the incoming worker is to read that record, check out the referenced code, and decide which claims it can rely on. The job of the finishing worker is just as important. It appends its own revision, command, environment, observed result, and what remains open. The code and test output can stay where they are. A link is enough if the next reader has access. If the browser wouldn’t launch, the record says so. A later worker can bring a working browser without having to rediscover the application bug.

Proposed workflowWhere does the next worker leave its answer?
  1. Claude CodeSaves the revision, verified expiry check, and untested return case.
  2. Shared task · TABS-1Keeps the checkpoint and a link to evidence. A Markdown file in Git is enough here.
  3. CodexReads the record, opens the revision, and checks the remaining case.
↩ Return to TABS-1The finishing worker appends its revision, result, and remaining uncertainty. In our trial, that reply stayed in chat.

Markdown gets me a readable exchange and a history in Git. If three workers can claim the same ticket at once, I need a reliable way to decide whose update wins. One option is a shared service backed by a relational store. Each worker reads the task ID and version, then submits an update against that version. The store accepts one claim and tells a late writer to reread. A unique ID for each event makes it safe to retry a write after a connection drops. Claude and Codex can use different clients as long as each understands those few operations and the meaning of the fields.

A knowledge graph would earn its keep when I want to follow relationships across tasks. Imagine a release depends on two tickets. One ticket contains a reviewer’s decision, the other supersedes the revision that reviewer inspected. In a graph, the lines have names: depends on, reviewed, supersedes. Following them answers “Which release decisions need another look after this change?” The same relationships can start life as linked IDs in Markdown or rows in a database. I’d add a graph database when questions like that become common enough to justify maintaining it. A searchable knowledge store can also help an agent find similar incidents by description. The search result should lead it back to the versioned decision and its evidence before it changes today’s ticket.

Decide who picks up the next task

“Use whichever agent has quota” is a good reason to want a router and an incomplete rule for writing one. A provider can have credit available while its worker lacks the repository, browser, or permissions needed to finish. Another may be eligible but already editing the same component. And if I have an hour left to review changes, dispatching ten more tasks can leave me worse off.

I’d make the choice in an order a teammate can inspect. First, is the task ready? It needs an outcome someone can recognise, its dependencies met, and an owner for unresolved decisions. Second, which workers are eligible for this repository and class of change? Third, among those workers, which has the tools, available budget, and least likelihood of colliding with work in flight? If a usage figure is unavailable, I’d record unknown and use an explicit policy for that case. Quietly treating unknown capacity as unlimited makes the bill the first reliable signal that something went wrong.

A dispatcher could do most of that with ordinary code. It can inspect labels, file overlap, open reviews, and explicit limits. It can then invoke the selected coding tool with a task ID, checkout, role, and instructions for recording progress. An interactive desk during the day and a scheduled local process overnight could speak that same small contract. If the worker reaches a limit, it parks the task at its last recoverable checkpoint. A replacement claims it before writing. A worker that wakes up late must discover that its claim expired.

I see three useful arrangements. For routine work, one writer owns a task while other writers take independent items from the backlog. For review, a second provider reads the exact change, knows the acceptance criteria, and records evidence for each finding. Different tools may challenge different assumptions, though two models agreeing still leaves an engineering decision to make. For a genuinely uncertain design, I might pay for two implementations in separate branches. They would start from the same revision and face the same tests. I could then compare their user-visible behaviour, complexity, and operating cost. That extra spend makes sense when an alternative might teach me something that another round of polishing the first answer would miss.

A board, a timeline, and a calendar answer different questions

Imagine the two-tab fix sat in In progress from Monday afternoon until Tuesday morning. Did an agent spend the night investigating? Did it run for ten minutes, exhaust its quota, and stop? Did the implementation finish before dinner and wait twelve hours for me? Each case calls for a different intervention. Moving the card to a new column erases the information I need to tell them apart unless something records the transition.

The board I want has a backlog, claimed work, parked work with a reason, work awaiting review, and accepted work. Opening a card should reveal its timeline. I want to see the first agent claim it, which revision passed the expiry check, why the task was parked, when another provider resumed it, and when a reviewer inspected the result. Where usage or cost can be attributed, I’d include it. Missing usage should stay missing. The log should link to the test output or pull request so I can check the story against something outside the log.

A Gantt or calendar view earns its place for a different reason. Thursday’s customer demo is a real commitment. A reviewer’s Tuesday availability is a real constraint. The finish time of an investigation into an unfamiliar browser bug is an estimate. Drawing all three as equally certain bars would make the interface attractive and the schedule misleading. I’d put human commitments on the calendar and observed work on the timeline. Their intersection tells me which parked task is worth picking up first.

This changes how I would measure throughput. I care about time from a handoff to the next useful action, repeated investigations, time spent waiting for review, and cost per accepted change. I’d measure those alongside defects and reopened work. If workers finish faster while the review queue grows older, I would slow dispatch and reserve time for review. Addy Osmani has described the coordination burden of supervising several coding agents. In my workflow, I’d use the length and age of my review queue to decide whether the next overnight worker starts. Osmani’s O’Reilly AI CodeCon write-up · The Orchestration Tax

How one update reaches several views

Suppose Codex picks up TABS-1 at 09:00, finishes a check at 09:08, and hands the revision to a reviewer at 09:10. Those times are illustrative. I’d record the task ID, run ID, actor, timestamp, revision, and evidence link with each event. I’d give the ticket a link back to that stream. From there the choice of view follows the question somebody is asking.

Illustrative workflowOne review request, five views of the work
Choose the latest event
Ticket board
TABS-1 · In progressTABS-1 · Awaiting review
Timeline
09:00 Claimed
09:08 Check passed
09:10 Review requested
Dependency graph
Thursday’s release → TABS-1 → browser check
Review backlog
2 tickets waiting3 tickets waitingLatest count in the review queue
Gantt chart
Review window · Tue–Wed◆ Thursday demo · planned

Both states use example times and queue sizes. Requesting review changes the board, timeline, and backlog. The dependency and promised demo date stay the same.

I’d keep separate run IDs for repeated attempts. A queue chart could then count tickets waiting at the end of each day, while a duration chart could pair review requests with decisions. An open review contributes its current age until someone accepts the change.

This also gives me a way to notice bad data. If a card says Verified and the only linked run died before the browser opened, I can follow the card back to the event that moved it. Correcting that event’s interpretation can repair the board and the metrics together. Asking someone to fix the card, the chart, and the ticket by hand would create three new opportunities for them to disagree.

Carry one requirement all the way to release

During the exploration I realised I could describe how to launch a worker more precisely than how to decide whether its output belonged in front of a user. Tracing one requirement through an ordinary software lifecycle made the missing pieces easier to see.

Discovery and requirements. “Both tabs should recover” sounds clear until two people demonstrate different meanings of recover. Does the untouched tab have to change immediately after sign-in? Is updating on its next reload sufficient? Someone with product authority has to settle that. A product requirements document can preserve the user problem, the chosen behaviour, and what falls outside it. An agent can draft those distinctions from the conversation. The original speaker should be able to correct them before they become instructions to a worker.

Design and planning. A functional specification can make the requirement implementable. Which component is authoritative about the session? What can be shared across tabs? What stays local to each tab? How should a delayed notification be handled? I’d attach the design and its open questions to the task, split work where dependencies allow, and ask for design review when a choice affects other teams. A small defect can use a paragraph. A change to a shared interface deserves a decision another team can find six months later.

Implementation and testing. For a bug, I want a reproduction before the change and the same check after it. A unit test can cover when the banner should clear. An integration test can establish what the session endpoint reports. A browser test with two real tabs can determine whether the other tab actually updates. Writing a test, running it, and passing it on the revision under review are three separate facts. If the worker changes the assertion at the same time as the implementation, the reviewer needs to see both changes. If the runner cannot start, that is an environment result and the behaviour is still unverified.

Demonstration and acceptance. I’d give the reviewer a short script with preconditions and something visible to observe. Open two tabs while signed in. Expire the demo session. Check each screen. Sign back in, reload, and look for the old banner. An engineer can run that script against the proposed revision. A product owner can watch it and notice that technically correct copy still leaves the user wondering whether their work was lost. Both judgements matter. A maintenance change may need only an automated check, while a new user journey benefits from showing someone the result.

Release and learning. Someone still owns the go-ahead, the rollback decision, and the signals to watch after release. I’d link the release back to the task, reconcile the ticket with the actual pull request, and draft an update for the person who reported the problem. A later production report should lead back to the evidence we saw and the cases we missed. That gives a retrospective a specific question to answer. Was the requirement ambiguous, was the test incomplete, or did the environment behave differently?

There are two demonstrations hiding in that sequence. The application demo proves that a user can recover across two tabs. The platform demo proves that another worker can find the right revision, resume the task, and present evidence a reviewer can use. I want to be able to fail either demo independently. Otherwise a good browser fix can disguise a poor handoff, and a tidy timeline can disguise broken software.

Which parts already exist?

Orca was an important reality check for me. Its open-source project already describes running different coding tools with your own subscriptions, across desktop, mobile, and remote environments. If my problem were simply “give me a place to work with several agents,” I’d start there. My evaluation would follow one task out of that environment. Could an overnight worker started elsewhere resume it? Could I link its local checks, the current pull request, and a human decision back to the same ticket? Those are integration tests I would run before treating a product gap as established. Orca

Other projects give me different starting points. Beads is a candidate for task identity and dependencies. TAKT describes agent coordination, human intervention and recording through workflows expressed in YAML. Either might remove a layer I otherwise have to write. A desktop tool makes sense when I want to steer several branches interactively. A headless runner makes sense when I want a constrained job to wake on a schedule. I’d choose each against a concrete job and give both the same handoff to read. Building my own coding agent would add a model integration, editor experience, and tool environment before I had learned whether my handoff was any good. Beads · TAKT

Why is assembling these pieces still difficult? Consider the word approved. In one team it can mean someone has refined a ticket enough for an agent to start. In another it means a reviewer has authorised a change to go live. A connector that copies that label across systems can appear to work while granting the wrong authority. Usage limits also come from different accounts, a background worker may lose its login while an interactive tool still works, and Git can move ahead of an issue tracker. Integration means deciding who owns each fact and what happens when the systems disagree.

My bias is to keep predictable decisions in code. A worker’s permissions can restrict what it writes. A repository check can require a reviewer and bind a passing check to a commit. A periodic reconciliation can detect that a merged change is still in the review queue. An event with a repeatable identity can make retrying a notification harmless. These are testable properties. Asking a model at the end of a long prompt to “please follow team policy” leaves the team with a much weaker answer when something goes wrong.

Let people steer where they already work

One of the ideas that excited me in this exploration came from meetings. Calendars, calls, transcripts, and task trackers already exist. An assistant becomes interesting when it connects them at the moment somebody would otherwise do the work by hand. If a calendar invite mentions a ticket, I’d like to arrive with the last decision, the open question, and a link to the relevant change. After the call, I’d like proposed tasks that retain who agreed to what and which decision depends on another. I can correct a misunderstanding while I still remember the discussion.

I can see the same opportunity in smaller rituals. At stand-up, a record of what changed yesterday could supply the first draft of my update. In the morning, a short list of reviews ordered by age and release impact would give me somewhere to start. If an overnight job loses access to an issue tracker, a single message when it fails, followed by one when it recovers, tells me more than a repeated hourly error. If a pull request merges, a draft reply in the originating thread can save the person who raised it from having to ask again. Each of these ideas has a testable payoff in an existing routine. None requires somebody to spend the day watching a new dashboard.

I also keep thinking about the way people steer a discussion online. A comment sits beside the thing it refers to. Someone arriving later can see the original and the response. Imagine putting “Keep the explanation visible if I refresh the sign-in page” on the task while an agent is working. The interface could show the resulting change to the acceptance criteria. I could accept it, edit it, or say I was only asking a question. A worker that had already started would learn that a requirement changed after its checkpoint. The original decision would still be there if we needed to understand why.

That would give me several ways to program the same outcome. I could type an exact identifier, sketch the two screen states, speak the requirement, or move a card to indicate that a human decision is pending. Each gesture needs a precise meaning. Dragging a card into a release column cannot manufacture a successful deployment. An approval ought to identify the person, the revision, and the evidence they saw. A comment that changes scope should reach the active worker before it declares the old scope complete.

From typing instructions to expressing intent

I used to pay a lot of attention to how quickly I could type. Speaking changes what I’m willing to put into a requirement. I can explain why an apparently minor detail matters, try two phrasings, and remember the awkward exception halfway through a sentence. Some of the most useful material in this exploration came out in exactly that order. Asking me to clean it all up before capturing it would throw much of that value away.

Spoken requirements also contain false starts. In the conversation behind this article, speech transcription turned Trello boards and Gantt charts into something quite different. A person can work out the intended meaning from the next sentences. I wouldn’t want a system quietly applying the same kind of guess to a project name, a priority, or the word approve. I’d show the transcript alongside the proposed task change, let the speaker correct it, and record the accepted wording. For sensitive discussions I’d want the option of local transcription and keeping only the approved requirement.

It reminds me of the move from assembly to higher-level languages. As programmers gained better ways to describe what they wanted, they still needed agreements about how parts fit together and how to tell that the result worked. A compiler has a formal language to operate on. A request like “make recovery feel natural” admits several reasonable implementations. The productive part of the analogy is asking what we need to standardise next. My candidates are the unit of work, the evidence that satisfies it, the handoff between workers, and the authority to accept it.

That leaves plenty of room for exploratory or “vibe” coding. Sometimes I need to see the screen to discover what I wanted. The point at which I’d ask for more structure is when somebody else has to rely on the result. A prototype can help me choose the behaviour. Once I promise that behaviour to a user, I want a durable requirement and a way to demonstrate that it survived the next change.

I also wondered aloud about brain interfaces. My interest is in the distinction between having a thought, expressing a proposal, and authorising work. Even if a future device captured the first step perfectly, a passing thought would still be a poor record of a product decision. An interface that lets me inspect and revise what it understood would be worthwhile with any input device. Voice gives me a reason to design that step today. The product can leave the hardware question open.

Could this support an open-source company?

The analogy I had in mind was Vercel. A developer pushes a change, a preview becomes available, a colleague can look at it, and there is a route to production. Much of what makes that experience valuable happens between tools the team already understands. I’d like an equally legible journey from “someone asked for this” to “here’s the revision we accepted, who accepted it, and what the user saw.” Vercel’s Git deployment workflow

Here is how I currently see the pieces, and where I’d put engineering effort.

Capability Starting point Missing piece I would build or test
Requirements and design Messages, tickets, meeting notes, design documents Intake that proposes one linked task, preserves uncertainty, and records who accepted the requirement
Planning and assignment Task dependencies, branches, existing agent runners Conflict-aware claims, parking and recovery, budget checks, and a limit tied to review capacity
Daytime and overnight execution Interactive coding tools and scheduled workers An adapter that gives each the same task, revision, role, and checkpoints
Observation and steering Issue boards, Git history, test output, and worker logs A board and timeline joined by task ID, with comments that become inspectable requirement changes
Proof, release, and learning Existing CI, code review, staging demos, and release processes Evidence attached to a revision, an explicit acceptance decision, and reconciliation with what actually shipped

I’d publish a handoff format, an event vocabulary, a small command-line reader, example adapters, and checks that another implementation can run. A reference implementation could store the current work locally, keep code and checkpoints in Git, and use a small database for events. Someone should be able to replace that database or use a different task tracker and still participate. Whether the authoritative handoff is a ticket comment, a versioned file, or a file with a pointer on the ticket is exactly the sort of decision I’d like real handoffs to settle.

There could be a company around hosting a multi-team timeline, managing roles and retention, connecting enterprise systems, and helping teams encode their own release rules. The commercial test is whether those services remain worth paying for when a team can take its task history and leave. I’d start with one workflow on one machine. Then I’d ask another team, with a different tracker and provider mix, to adopt it. If onboarding them requires rebuilding the core, what I have is a useful custom integration. If an adapter and a policy file are enough, that would be evidence for a product.

The order I’d build it in

First I’d make a stalled worker visible. Give each claim an owner and a last checkpoint. Detect when a worker disappears. Reconcile the queue with the actual state of its branch or pull request. Deliberately interrupt a run and find out whether someone can tell the difference between still working, parked, and waiting for me. This can start as text output.

Next I’d exercise the handoff between two providers, save the evidence, and open a timeline for that one task. The second provider should be able to resume the same revision, name the unanswered question, and make progress. I’d record repeated investigation separately from a sensible decision to rerun a test. Then I’d interrupt a worker before it can produce its final summary and see what the last ordinary checkpoint is worth. A planned switch and an abrupt stop put different demands on the design.

Only after that would I automate intake. I’d first have the morning assistant propose routes while I choose them myself. Disagreements would tell me what an “agent-ready” label actually means in my work. Then I’d allow one well-bounded class of task into the overnight queue, with the ability to pause it and a limit on outstanding review. After that, I’d connect an interactive desk, add a separate reviewer, and follow one real change through its demo and release. Each stage gives me a working capability even if the larger platform never materialises.

There are decisions I want to leave open. How often should a checkpoint be written before the cost of maintaining it exceeds the work it saves? When does a changed requirement invalidate a running attempt? Which costs can I fairly attribute on a subscription shared with interactive work? What evidence does a product owner actually read when accepting a change? A protocol written before trying those cases can easily standardise the fields that are easiest to collect.

What I think software delivery could look like in ten years

I can imagine one future where most of my working day takes place inside a provider’s environment. That might be convenient enough for many teams. I can also imagine a future where the pull request and CI system absorb nearly everything, and an agent becomes another process that proposes a patch. The possibility I’d like to work towards leaves room for either interface while giving the team an independent record of what it asked for, what happened, and what it accepted.

In that version of a morning, I can speak a requirement on the way into a meeting. A colleague can correct it on the task. An overnight worker can implement the agreed version. Another provider can reproduce the result. I can open the card, see what the user would see, and ask for one change without reconstructing the conversation that started it. There are still difficult engineering and product decisions in that day. I’d get to spend more of it making them.

The first question I’d ask of any tool that promises this future is a modest one. Give me a half-finished task, take away the chat it began in, and show me what the next worker can actually do.

I tried that first step twice on the two-tab bug. With and without Claude’s handoff note, Codex finished the written task without asking me to explain it. The fixes behaved differently in a tab left untouched after sign-in. The evidence differed too. One worker ran Chromium and the other used a simulation. Both left their final verification in their own conversations. Those are exactly the distinctions I’d want a shared task record to preserve. Read the experiment and its results