Right now, when you want a coding agent to build something, you open Codex. You read its questions, you approve its plan, you check its work, you tell it when it is wrong. You are the loop. You are the one closing it.
I wanted my agent to close that loop instead.
My agent, Cal, is the one who should be talking to Codex, not me. It knows what we are building and why. So I built the thing that lets it happen: a loop that lets one agent delegate a task to another, follow the work, answer the questions, and bring back the finished result, with me stepping in only when a real decision is needed. Cal to Codex is my first example of it.
Because here is what I think is coming.
Why This Matters to Everyone
Today every agent is built for a human user. Codex or Claude Code optimizes for the developer at the terminal, or the worker inside their app. The user they picture is you.
But the direction all this is headed is clear: you are not the direct user, your agent is. That is one abstraction level higher.
And this is exactly what I did. I made my agent, Cal, an agent harness, orchestrate Codex the way a tech lead manages a senior engineer. Soon you will not be the one delegating to ten different agents and orchestrating their work. Your agent, your digital twin, will do it on your behalf. The user of Codex will not be a person. It will be another agent.
When that is true, the loop between agents becomes the most important piece of infrastructure there is.
There is a second reason why this matters, and it is about freedom.
Two or three large companies will try to lock you in, and that is the natural move: make their agent the one you live inside, so leaving costs you everything you built. And in a competitive market, the agents from rival labs will probably not work smoothly together. We have seen this before. Applications live on both Windows and Mac, but Apple chose the more closed path, and the same app rarely behaves the same on both. I expect Codex and Claude Code to sit in exactly that kind of standoff. Tight compatibility between competitors is not something you should count on.
So if you weld your whole workflow to one of them, you inherit its ceiling and its walls.
The delegation loop is the way out. If my agent owns the loop, then Codex, Claude Code, or whatever general-purpose agent arrives next, is just an executor it calls. Give me the right endpoints and I can plug any of them in. The future is not choosing the one agent to rule your work. It is working with all of them, drawing on the strengths of each, and keeping the freedom to swap any of them out.
What the Loop Looks Like
Now that the why is clear, here is the shape of the what.
Cal orchestrates Codex much like a tech lead works with a senior engineer. It frames the task, follows the work, answers questions from existing context, and brings the result back.
Underneath, the loop rests on six pillars:
- Strand isolation, so the coding agent's work does not flood my conversation.
- Message relay, so I see the meaningful moments and not the noise.
- Lifecycle management, the structured handshake of context, questions, approval, and review.
- Visibility, so my agent can always query what the other agent is doing.
- Completion notification, so nobody has to poll.
- Thread continuity, so the collaboration survives even if my agent restarts.
I will go deeper on those another time. What matters here is that every one of them exists to do a job a human does without thinking, and that a delegating agent cannot.
Food for Thought, for the Labs
If you are building Codex, or Claude Code, here is what I think you are optimizing for: the CLI, the IDE, the human reviewing diffs and approving changes. Single sessions, one task at a time, a person in the loop.
Here is what I think you are not building for yet: another agent as your user. An orchestrating agent needs things a human never asks for. Full access to what your agent said, not a truncated preview. Structured events, not terminal output meant for eyes. The ability to find and resume a thread after the orchestrator restarts. A way to relay questions out and answers back across three hops, not one. This is the abstraction gap, and it is the gap between building for people and building for the agents that will soon be your real power users.
Where This Goes
Here is the future I am building toward.
I have one agent. It works with Codex on one task and Claude Code on the next, choosing whichever is cheaper or better for the job, and I never think about which. When I need something outside coding, it reaches further. A healthcare agent. A legal agent. Instead of me navigating those services, my agent talks to their agents.
I stop dealing with entities. My assistant deals with their assistants. My work gets understood, orchestrated, delegated, and closed by the one agent that is always there for me.
The loop I built to make Cal talk to Codex is a small first instance of that. But it is the same loop. And I think it is the one worth getting right.
Written after building the delegation loop between Cal and Codex, part of an ongoing project on agent harnesses. Ideas, views, and opinions are my own and do not represent those of any organization I am affiliated with.