Use ordinary chat for work that ends with the current answer. Use DuoDuo when the work runs for months and you want what builds up along the way, its live context, to stay on your machine and carry over to the next model.
| Need | One-turn chat | DuoDuo |
|---|---|---|
| Answer a question now | Excellent | Also works, with more machinery |
| Own the durable state | Depends on the provider | The filesystem is the database; the event log is the source of truth |
| Resume the same project later | Depends on the client | Open the project and continue its durable session |
| Carry guidance across conversations | Usually retrieval, or the client's own memory feature | A scheduled subconscious distills event evidence into the intuition layer |
| Think without a new message | Usually idle | A cadence wakes one eligible subconscious partition at a time |
| Review what it has learned | Depends on the provider's memory feature | Lessons and the intuition layer are Git-tracked files with a diff and a revert |
| Run recurring work | Needs another scheduler | /loop creates a file-backed job and reports back |
| Move between chat and editor | Separate integrations | Channels connect to one installation and its sessions |
| Use other AI assistants | Each keeps its own memory | Tether hands DuoDuo's context to the Grok app, Dots in ChatGPT, or Meta's Muse over MCP, so each answers as DuoDuo |
| Inspect delivery and recovery | Depends on the client | Events, mailboxes, sessions, jobs, output, and usage are visible files |
| Show interactive UI | Usually links or Markdown | Widgets create durable dashboards, forms, and simulations |
| Run on your own machine | Depends on the service | The daemon, CLI, filesystem body, and kernel run locally |
| Benefit from model progress | Re-evaluate your stack per release | Claude, Codex, Grok, and Pi run as peer runtimes; a new release lands in the same environment: the day you upgrade a CLI for Codex and Grok, or with the next DuoDuo release for the embedded Claude and Pi |
DuoDuo and a coding harness#
If you already use Claude Code, Codex, Grok, or Pi, you keep it. DuoDuo runs all four as peer runtimes and is the layer they sit in.
| Need | A harness on its own | DuoDuo around it |
|---|---|---|
| Continue yesterday's work | Reopen and re-explain, or reload a transcript | Open the project; the session and its history are already there |
| Reach it from somewhere else | It lives in one terminal or editor | The same installation answers from Feishu/Lark, an editor, or a room |
| Work while you are away | Runs while you watch it | Jobs run on a schedule and report back |
| Think without being asked | Idle between prompts | A cadence wakes one subconscious partition at a time |
| Keep what it learned | Ends with the process | Distilled into an intuition layer every new session loads |
| Switch runtimes | Start over in the other one | Same session, same tools, same history; pick per session, job, or channel |
| Know what happened when it was interrupted | Whatever the transcript preserved | Every message is on disk before it runs; the session resumes from its own state, and the event history says what reached it |
| Use your subscription | Depends on how that harness authenticates | Each runtime uses the vendor's own client and your existing login |
What makes a harness worth having (its loop, its native tools, your extensions) stays where it is. DuoDuo adds what has to outlive one process.
DuoDuo and the assistants you already use#
The Grok app, Dots in ChatGPT and Meta's Muse are where a lot of talking already happens, and each has a memory feature of its own. You keep talking to them. Through Tether each one starts from DuoDuo's live context and answers as DuoDuo.
They have memory, so why add DuoDuo?
| Question | An assistant's built-in memory | DuoDuo's live context |
|---|---|---|
| Where is it kept | In that vendor's account | Files on your machine |
| Who can read it | That assistant | Any assistant or harness you connect |
| What happens when you switch | It stays behind | It comes along; the new one reads the same board |
| How it changes | The vendor's process, mostly unseen | A scheduled subconscious, each change with its evidence and a diff |
| What it covers | Conversations in that app | Every channel: terminal, editor, chat, room, phone, and those assistants |
As these assistants improve, they do more with the same context. None of them can ship that context, because it comes from your own work.
DuoDuo and agent frameworks#
Frameworks such as Hermes Agent and OpenClaw ship a complete agent: their own loop, tools, skills and memory. DuoDuo does not build a loop. It runs Claude Code, Codex, Grok and Pi whole and keeps what has to outlive them.
| Question | An agent framework | DuoDuo |
|---|---|---|
| Who maintains the agent loop | The framework | The harness makers; DuoDuo runs their releases as they ship |
| Where effort goes | Tools, skills and integrations | The record, the subconscious and the intuition board |
| What a new model release means | The framework adapts its loop | The same live context, read by a better model |
| How learning is reviewed | Depends on the framework | Git: every line cites its events and can be reverted |
A framework is the better choice if you mainly want ready-made skills and integrations. DuoDuo is for keeping what an agent has learned about your work.
Choose ordinary chat when#
- the task ends with one answer
- no schedule, background reflection, or delivery path is needed
- the provider already owns all the continuity you want
- you do not want to operate a local daemon or filesystem state
Choose DuoDuo when#
- conversations and work must survive process restarts
- the event history needs to be auditable and recoverable
- background cognition should tend the intuition layer without blocking the foreground
- selected experience should become inspectable intuition
- several surfaces need to share one identity and host
- an agent needs recurring jobs or richer UI than text
Running DuoDuo means operating a local daemon and its files. Now and then you will check health, cost, cadence or Git history, usually by asking your DuoDuo. In return, continuity and what it learns stay visible and under your control.