In this video, Nate B. Jones (AI News & Strategy Daily) names a pain that anyone juggling multiple AI tools knows well: you are the only thing connecting Claude, ChatGPT, and Codex. You copy output from one tool, paste it into another, re-explain context, and carry the work between systems that do not talk to each other. His answer is a system he calls Open Engine, designed to make that invisible coordination work disappear so your agents start acting like a system you can operate instead of separate subscriptions.
The core promise: get your agents to stop behaving like separate products and start handing off work to each other (and to humans) without you being the messenger. It works for teams of humans and their agents, and for households, because the underlying shape of handoff pain is the same.
Nate frames the pain through a friend who has a baby, runs an agency, and uses Claude Code with loops and automations. She is fluent in AI. Her problem is not learning the tools, it is that she uses at least five different AI systems, each helping with one piece of the day, and she becomes the person who carries the work between them.
You cannot simply swap the tools out, because they are genuinely different. As Nate puts it: Claude is better at front-end design (it is intuitive), while OpenAI has a strong reputation for back-end engineering. So people who understand these tools end up "driving their own harnesses," coordinating themselves across tools to get their preferred model on each problem. That coordination is real, painful labor that AI-productive people simply absorb because the payoff is so high.
His memorable image: if every loop (research, writing, support, coding, scheduling) lives in its own room, the human becomes the hallway. The research loop finishes and the writing loop never learns what changed. The coding agent fixes a file, but the teammate who owns review only sees a vague summary unless you forward a pile of chats.
Nate is precise about what actually hurts. It is not a model problem and not an agent-capability problem. It is a boundary problem, the seam between agents:
He notes that tools like OpenClaw (action-oriented agents) and Hermes (agents that learn from repeated work) address real desires, but a very capable private agent can still become "another inbox or task queue you have to manage." Autonomy alone is not enough. The bottleneck Nate cares about is the handoff: who gets this next, and how do we pass it cleanly?
The central move is deliberately simple. Put the work in a queue that both people and agents can read and write to. A queue can be Jira, a kanban board you coded, or a Linear ticket queue (Nate's preference). The specific tool does not matter; what matters is that it is a shared, readable, writable system of record.
A good ticket says: what needs to happen, who owns it, the background that matters, what the agent is allowed to do, where it should stop, and what it must show when done. That structure turns "asking an AI for help" into "giving it a job the next person or agent can understand."
Prompt vs. Ticket: A prompt asks for an answer. A ticket asks for a result to get done, and it can involve multiple agents that are not directly integrated. The ticket becomes the place they talk.
Why not a chat box or Slack? Because, as Nate argues bluntly, a chat box is a terrible way to manage state, and so is Slack. An agent needs to change files, create tasks, move statuses, and write drafts in a place where you can actually see what happened and audit it from any command line, not by querying chat transcripts.
Nate's specific build has five pieces that only work as a complete set; miss one and it does not hang together:
These skills are explicitly compatible with OpenClaw or Hermes. Nate is clear this is not anti-OpenClaw: "I love what OpenClaw has done... you can use those tools as much as you want," and you are not limited to only those tools.
The basic Open Engine loop, as shown: a request becomes a clear Linear task assigned to the right operator. Then:
The receipt is not decoration. Nate's point: "I don't want to ask the agent, did you do the thing? I want to know it got done." No more copy-paste, no more manual coordination between LLMs.
His delegation example: Maya asks Codex to route a metrics task to Leo's agent, which happens to be Claude. Codex checks that Leo's agent is online, writes a self-contained Linear issue with all needed context, assigns it, and labels it "agent instructions." Leo's agent picks it up on its own heartbeat. That is two different people's agents, from different LLM providers, coordinating in Linear, with a visible handoff whose scope is not buried in chat.
Request → issue → claim → work done → receipt → next item. If an agent hits ambiguity, it does not guess. It moves the issue to needs input and asks the exact blocking question. The human answers on that issue, the agent resumes, and the audit trail stays in one place.
Open Engine pushes you from "prompt mode" to "work mode." The model can be the same; the assignment is far clearer:
A key distinction Nate draws: Output is what the AI returns right now. Work is what someone can review, accept, and build on. A beautiful brief written in a private chat that nobody knows about is just a draft in a room by itself. Open Engine is about getting from output to work without making humans the copy-paste path.
Nate offers a simple gut check for whether a system is doing this job:
If yes, even in a small way, the whole conversation shifts. You stop asking "what can one AI do in this session?" and start asking "what kind of work can my whole system carry without me being the messenger?"
The pattern is identical for a school-pickup change and a sales pipeline: something changes, several things now depend on it, some parts can be handled by agents, some need a person. Open Engine does not replace the person, it just keeps the person from being the only one handing all of this off. Nate reports it has been a major load off for both his family (picking paint colors while moving houses) and his team (tagging each other's agents in, with a clear system of record instead of tracking agent messages in Slack).