Grab the Open Engine guide: the copy-paste task record that makes one AI's work the next AI's job, with receipts

You finish a client call and the work starts its commute. The transcript goes to Claude to find the argument. Codex changes the file. ChatGPT reads the draft again. A browser agent checks the page actually rendered. Slack has the conversation, Linear has the task, and the calendar decides whether any of it survives the afternoon.

That’s not seven jobs. It’s one job crossing seven systems. And every time it crosses, you carry the state: what was decided, what source mattered, what changed, what the next tool is allowed to touch.

I don’t want one of those tools to swallow the others. Most serious AI users I know don’t either. They have preferences. They know Claude is better at one thing, Codex at another, a local agent at a third, and they don’t want to crown a favorite and pretend the rest of the world disappeared. The trouble isn’t that we own too many good tools. It’s the boring middle between them, the place where one tool’s result becomes the next tool’s task with its source and limits still attached, and for most of us that middle is still a person. Right now, the integration layer is you. It doesn’t have to stay that way.

If you can code, you can build your way around this. You can wire the tools together with APIs, a custom harness, a few cron jobs, and for engineers that’s getting easier every month. But that’s not an answer for everyone else, and it’s barely an answer for a team. The need underneath isn’t exotic. You want one AI’s result to become another AI’s task, with the sources attached, the limits visible, and enough of a trail that the next person or agent doesn’t have to read a giant chat to catch up.

I know a product lead with a newborn and an agency. She runs Claude Code, she has loops and automations, she’s looked hard at OpenClaw. She’s not new to any of this. Her problem is smaller and more maddening than that. A client call collides with a baby appointment. The product scoping still has to move, the team still needs to know what changed, and she’s the one copy-pasting the state of her life between five tools while holding a baby. That’s the load Open Engine takes off her. Not the judgment. Not the taste. The handoffs around them.

I’ve been running a working version to get content out, organize my life, move houses, and coordinate with my team. I’m releasing it now because the next real AI problem isn’t “which model is smartest.” It’s whether the work can move between models at all.

Here’s what’s inside:

• Open Engine itself. The build I actually run, packaged as copy-paste templates you hand to the AI you already use, so you have a loop running today.

• The handoff, not the model. Why the thing that breaks is never “can the agent do it” but “can the work survive the trip to the next tool.”

• The smallest useful version. A shared task list and a seven-part task record that carry the job across tools, so a good answer stops dying in a private chat.

• The one-loop audit, and the 30-minute build. Nine questions that turn one annoying handoff into a task an agent can claim, pause, resume, and finish with evidence.

• The receipt. The short vocabulary that keeps an agent accountable after the run ends, so “done” stops meaning “now go audit it yourself.”

• Teams, and the rest of the field. How one person’s agent hands another person’s agent real work, and where this sits next to OpenClaw, Hermes, and Symphony.

Start where everyone feels it first: the moment the work has to leave one tool and land in the next.