Use ordinary chat for work that ends with the current answer. Use DuoDuo for file-backed continuity, scheduled background work, or intuition that carries across sessions.
| 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.
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.