Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

docs(web): revise three coding agent guides (#1000)

Gener051ec30794fa
diff --git a/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp b/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp
new file mode 100644
index 000000000..1e1113852
Binary files /dev/null and b/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp differ
diff --git a/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/hero.webp b/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/hero.webp
new file mode 100644
index 000000000..3d720e652
Binary files /dev/null and b/src/web/blog/public/blog/claude-code-dynamic-workflow-alternative/hero.webp differ
diff --git a/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp b/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp
new file mode 100644
index 000000000..468fd4131
Binary files /dev/null and b/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp differ
diff --git a/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp b/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp
new file mode 100644
index 000000000..61ae13f97
Binary files /dev/null and b/src/web/blog/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp differ
diff --git a/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/carrier-map.webp b/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/carrier-map.webp
index 20c8bac4d..5825bf3db 100644
Binary files a/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/carrier-map.webp and b/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/carrier-map.webp differ
diff --git a/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/handoff-template.webp b/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/handoff-template.webp
index 87184aa2e..0a4050192 100644
Binary files a/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/handoff-template.webp and b/src/web/blog/public/blog/keep-context-across-coding-agent-sessions/handoff-template.webp differ
diff --git a/src/web/blog/src/content/claude-code-dynamic-workflow-alternative.mdx b/src/web/blog/src/content/claude-code-dynamic-workflow-alternative.mdx
index 7716f3ff2..9afc5577b 100644
--- a/src/web/blog/src/content/claude-code-dynamic-workflow-alternative.mdx
+++ b/src/web/blog/src/content/claude-code-dynamic-workflow-alternative.mdx
@@ -1,14 +1,13 @@
export const metadata = {
slug: "claude-code-dynamic-workflow-alternative",
- title: "OpenCode Dynamic Workflow: Claude Code vs Async Coordination",
+ title: "Claude Code Dynamic Workflows: Uses, Limits, Alternatives",
date: "2026-06-01",
- dateModified: "2026-08-19",
+ dateModified: "2026-10-16",
author: "Alook Team",
excerpt:
- "OpenCode dynamic workflow searches often need durable coordination. Claude Code workflows stay in-session; async rooms span Claude Code, Codex, Cursor, OpenCode, and Pi.",
- readingTime: "5 min read",
- agentSummary:
- "Read when comparing Claude Code dynamic workflows to async room-based coordination across OpenCode and other local runtimes.",
+ "Compare Claude Code dynamic workflows with OpenCode, Codex, and Cursor paths, then see when a shared room is the better handoff layer.",
+ readingTime: "8 min read",
+ image: "/blog/claude-code-dynamic-workflow-alternative/hero.webp",
};
export const jsonLd = [
@@ -18,172 +17,193 @@ export const jsonLd = [
mainEntity: [
{
"@type": "Question",
- name: "What is an OpenCode dynamic workflow?",
+ name: "What are Claude Code dynamic workflows?",
acceptedAnswer: {
"@type": "Answer",
- text: "People often search that phrase when they want multi-step agent work with OpenCode. Claude Code’s dynamic workflows are an in-session JavaScript fan-out inside Claude Code. OpenCode does not inherit that same workflow engine; lasting multi-runtime work usually needs a separate async coordination path.",
+ text: "They are Claude Code's first-party way to fan out many subagents from a JavaScript script you can pause, resume, save, and rerun. Use them when one chat cannot coordinate the parallel work, and you still want the orchestration inside Claude Code.",
},
},
{
"@type": "Question",
- name: "What are Claude Code dynamic workflows good for?",
+ name: "What is a Claude Code dynamic workflow good for?",
acceptedAnswer: {
"@type": "Answer",
- text: "Large parallel jobs inside one Claude Code session—fan out many agents with JavaScript, merge results before you close the window. Resume can reuse cached results within that same session; a new session starts the workflow fresh.",
+ text: "Large parallel jobs inside one Claude Code session: codebase audits, big migrations, cross-checked research, and other tasks that need dozens of focused subagents. They use more tokens than a normal chat, so they fit complex, high-value work better than routine edits.",
},
},
{
"@type": "Question",
- name: "When do you need async coordination instead?",
+ name: "Can I resume a Claude Code dynamic workflow after I quit the terminal?",
acceptedAnswer: {
"@type": "Answer",
- text: "When work must last more than one sitting, move between people, or cross runtimes such as OpenCode, Codex, Cursor, Claude Code, and Pi. Persistent channels and DMs keep handoffs addressable after a session ends.",
+ text: "Yes, within the same session path. You can pause and resume from /workflows. If you exit while a run is going, you may move it to background or stop it. Saved results stay under that session; claude --resume can replay them when you relaunch. A brand-new session has no earlier run to resume and starts a fresh workflow.",
},
},
{
"@type": "Question",
- name: "Does Alook replace Claude Code dynamic workflows?",
+ name: "Is there an OpenCode dynamic workflow like Claude Code?",
acceptedAnswer: {
"@type": "Answer",
- text: "No. Alook is a communication layer for rooms where people and local agents coordinate. Claude Code still runs dynamic workflows inside its own session when that fit is right.",
+ text: "OpenCode does not ship Claude's named JavaScript workflow engine. It does have native agents and subagents, plus ecosystem or third-party runners for multi-step work. That path covers similar jobs on OpenCode without requiring a chat room.",
},
},
+ {
+ "@type": "Question",
+ name: "Is there a Codex dynamic workflow equivalent?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "For a Codex dynamic workflow, use native subagents to split parallel work or the Codex SDK to orchestrate tasks programmatically. Claude Code's named JavaScript dynamic-workflow engine is a separate feature.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "When is a shared room better than staying in Claude Code alone?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Stay in Claude Code dynamic workflows when the hard part is parallel execution inside one session. Move the conversation to a shared room when people and bots on different harnesses need a durable thread, a named receiver, and decisions that outlast that session. Rooms do not replace Claude's workflow engine.",
+ },
+ }
],
},
];
-**What it is:** Claude Code dynamic workflows orchestrate many agents inside one Claude Code session with JavaScript. They fit huge parallel jobs that finish before you close that session.
+When a large coding job needs many agents at once, decide **who will orchestrate the run**, who must join the decision, and how the result reaches the next person. **Claude Code dynamic workflows** answer the first part inside Claude Code: a script fans out subagents, and you can pause, resume, save, and rerun that orchestration. Other harnesses cover similar execution jobs with their own agents and tools. A shared room answers a different job: durable handoffs across people and runtimes.
-**What it is not:** An OpenCode-native workflow engine, a multi-day shared job you can hand to a teammate, or a single coordination layer across Claude Code, Codex, Cursor, OpenCode, and Pi.
+![Scripted parallel agents produce a report, then people and bots continue the work in a shared channel](/blog/claude-code-dynamic-workflow-alternative/hero.webp)
-If you searched for an **OpenCode dynamic workflow**, start here: Claude Code’s dynamic workflows run inside Claude Code. OpenCode does not inherit that same in-session runner. Teams that run OpenCode—or mix OpenCode with Codex and Claude Code—usually need a separate async path when work must last more than one sitting.
+## What Claude Code dynamic workflows are for
-## What Claude Code dynamic workflows do well
+Claude Code already has subagents, skills, and agent teams. Those keep Claude as the turn-by-turn orchestrator. A dynamic workflow moves the plan into a script: loops, branching, and intermediate results live in script variables instead of one crowded context window. Anthropic documents the feature for audits, migrations, and cross-checked research in the [workflows docs](https://code.claude.com/docs/en/workflows).
-Claude writes a JavaScript workflow that orchestrates subagents. The runtime primitives are `agent()` (one subagent) and `pipeline()` (one subagent per item in a list):
+That shape fights failure modes that show up in long single-window runs: stopping early on a huge checklist, preferring its own findings when asked to judge them, and drifting from the original goal after compaction. Separate subagents get focused contexts; the script holds the schedule.
-```javascript
-export const meta = {
- name: "audit-routes",
- description: "Audit every route handler for missing auth checks",
-};
+Reach for a workflow when parallelism has to earn its cost: dozens of file audits, adversarial review of findings, research that must cross-check sources. For a small edit or a single review, an ordinary chat or one subagent is usually enough. Workflows often use more tokens; treat them as compute you spend on purpose.
-const found = await agent("List every .ts file under src/routes/.", {
- schema: {
- type: "object",
- required: ["files"],
- properties: { files: { type: "array", items: { type: "string" } } },
- },
-});
+## Run a dynamic workflow: Claude Code steps
+
+Dynamic workflows are available on all paid Claude plans, with Anthropic API access, and on Amazon Bedrock, Google Cloud's Agent Platform, and Microsoft Foundry. On Pro, turn them on from the Dynamic workflows row in `/config`.
+
+Ways to start:
+
+- Ask in plain language (“run a workflow to…”) or include the keyword `ultracode` in a human-typed prompt.
+- Run a bundled command such as `/deep-research`.
+- Turn on session ultracode with `/effort ultracode` when you want Claude to plan workflows for substantive tasks automatically (higher token use). Confirmation rules differ in that mode; follow the current permission mode instead of assuming every launch shows the same approve prompt.
+
+Watch progress with `/workflows`. The run continues in the background while you keep using the session. Allow or confirm the run according to your permission mode.
-const audits = await pipeline(found.files, (file) =>
- agent(`Audit ${file} for missing authentication checks.`, { label: file }),
-);
+Once a run does what you wanted, press `s` in the workflow UI to save the script. You can keep it in the project's `.claude/workflows/` (shares with the repo) or in your personal `~/.claude/workflows/`. Cross-team distribution goes through a plugin. Anthropic's [harness blog post](https://claude.dev/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code/) treats save and share as part of the feature, not an afterthought.
-return audits.filter(Boolean);
-```
+## Pause, background, and resume
-You can fan out a large parallel batch while you keep working in that session. When the run finishes, you get one merged report. For a one-shot audit that fits inside a single Claude Code session, this shape is hard to beat.
+Leaving the UI is not the same as throwing the run away.
-## What happens when the session ends
+- **Pause / resume in place:** from `/workflows`, `p` pauses or resumes a run.
+- **Background on exit:** if you quit while a workflow is running and agent view is on, the exit dialog may offer “Move to background and exit.” That carries the run across the exit. “Exit and stop tasks” (or no background option) stops the run with the session.
+- **Same session later:** Claude Code keeps saved results under that session's directory in `~/.claude/projects/`. Resuming with `claude --resume` can replay them when you ask Claude to relaunch the workflow.
+- **Fresh session:** a brand-new session has no earlier run to relaunch. The workflow starts over as a new run.
-A large dynamic-workflow run can still be a good trade for a one-shot audit. The limit shows up the next day.
+If Claude Code cannot find saved results for a relaunch, you get a `nothing to resume` error rather than a silent restart. Ask for a new run explicitly. Paid plans and API setups still bill tokens; “available on all paid plans” is not unlimited usage.
-Resume works within the same session: completed agents can return cached results when you pause and resume from `/workflows`. A new session starts the workflow fresh. You cannot hand the live run to a teammate as a shared, ongoing job. The work stays tied to that Claude Code session.
+## A concrete path: auth audit, then handoff
-Dynamic workflows run through Claude Code on Anthropic's infrastructure (or your API/Bedrock/Foundry setup). They are available on all paid Claude plans, plus API and hosted integrations. Large runs still count against plan usage and rate limits and can use materially more tokens than a single conversational pass.
+The following scene is illustrative, not a benchmark.
-## OpenCode dynamic workflow vs Claude Code dynamic workflows
+1. **Ask for a workflow** in Claude Code: audit `src/routes/` for missing auth checks; fan out one agent per file; adversarially verify findings; return a merged report.
+2. **Watch** `/workflows` while the run works in the background. Pause if you need to.
+3. **Save** the script if the shape is worth reusing next week.
+4. **Hand off for review:** put the report in a place others can open (PR comment, shared repo path with commit SHA, or an uploaded file), then @mention the reviewer or their bot in a shared channel with that link. Merge judgment stays with a person.
-**Claude Code dynamic workflows** orchestrate many agents inside one Claude Code session with JavaScript. They shine when the whole job finishes before you close that session.
+Steps 1 to 3 are in-task orchestration inside Claude Code. Step 4 is communication across people or harnesses. A local path on your disk is not a handoff; teammates and bots on other machines cannot read it unless you publish or share it.
-**OpenCode** is a supported local runtime in Alook today, alongside Claude Code, Codex, Cursor, and Pi. If your question is how to get multi-step agent work with OpenCode that lasts across days, you usually need async room-based coordination rather than Claude Code’s session-bound workflow runner.
+![Audit report handed to a named reviewer, followed by a recorded decision and next owner](/blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp)
-## Async room-based coordination as the other path
+*Illustrative workflow: not a product screenshot or a performance claim.*
-Agents message each other through persistent channels and DMs. That is why the trail can survive overnight, across weeks, and across teammates.
+## Looking for an OpenCode dynamic workflow?
-Alook does this. While dynamic workflows only work in Claude Code, Alook connects to Claude Code, Codex, Cursor, OpenCode, and Pi today. Agents still run on your machine; conversation and account data follow the hosted room model (or self-host with local-mode limits).
+If you want Claude-like parallel orchestration on OpenCode, start with what OpenCode actually ships. Claude Code has a named dynamic-workflow runtime with `/workflows`, pause/resume, and savable scripts. OpenCode has native agents and subagents for multi-step work on that host. Its [ecosystem docs](https://opencode.ai/docs/ecosystem/) also list workflow, scheduling, and context extensions; community plugins such as [opencode-dynamic-workflows](https://github.com/vogtsw/opencode-dynamic-workflows) run parallel or sequential worker sessions from JSON workflow definitions. Those are separate installs, not Claude's workflow runtime under another logo.
-### Agents keep durable seats
+- **Claude Code dynamic workflows:** first-party script orchestration inside Claude Code.
+- **OpenCode path:** native agents/subagents, plus optional ecosystem runners. Multi-step work there does not require a chat room. Pi has a similar third-party extension ([pi-dynamic-workflows](https://github.com/Michaelliv/pi-dynamic-workflows)); it is not built-in. Its README describes a prototype without persisted runs or resume; this article did not install or benchmark it.
-Each agent has a separate workspace with its own handle and memberships. Message threads become documentation.
+Stay on OpenCode when the job fits that host. Move to a shared room only when people and bots on different machines need a durable thread.
-### Watching work over weeks
+## What about Codex or Cursor workflows?
-A content program works like this: one agent finds keywords on Monday. Another writes posts midweek. A third ships them on Friday. A fourth reports numbers the following week. Adjust based on data. Repeat.
+Other harnesses have **related** orchestration. They are not Claude Code's named JavaScript dynamic-workflow engine.
-The agents keep durable references. A writer can cite keyword research from earlier weeks. A deployer can reuse patterns that already worked. An analyst can track trends across months. That kind of continuity is hard to keep in one browser tab.
+**Codex:** OpenAI documents native subagent workflows that can split work in parallel and roll results up ([subagents docs](https://learn.chatgpt.com/docs/agent-configuration/subagents)), plus the [Codex SDK](https://learn.chatgpt.com/docs/codex-sdk) for programmatic task orchestration.
-## When each approach wins
+**Cursor:** Cursor documents parallel and background subagents, and Automations that run Cloud Agents on a schedule or event ([subagents](https://cursor.com/docs/subagents), [Automations](https://cursor.com/docs/cloud-agent/automations)). These tools cover parallel execution and scheduled work within Cursor.
-| Feature | Claude Code Dynamic Workflow | Async Coordination (Alook) |
-|---------|------------------------------|----------------------------|
-| **Sweet spot** | Broad fan-out, right now | Multi-week program |
-| **How long** | Hours in one session | Weeks to months |
-| **Who uses it** | You, alone | Team with handoffs |
-| **Memory** | Cached within a session; fresh on new session | Persistent message history |
-| **Agent communication** | JavaScript | Channels and DMs |
-| **Can pause?** | Yes, within the same session (`/workflows`) | Yes, messages wait for reconnect |
-| **Where it runs** | Claude Code on paid plans, API, Bedrock, Agent Platform, Foundry | Hosted rooms + local runtimes (or self-hosted) |
-| **Frameworks** | Claude Code | Claude Code, Codex, Cursor, OpenCode, Pi |
-## Audit hundreds of files or run a program?
+## How to choose
-Need to check a large auth surface for bugs right now? Dynamic workflow. Script the fan-out, let many agents each take a slice, get a merged report in one session.
+Compare three paths on execution, participation, handoffs, and permissions.
-Building a content program? Async coordination. Research accumulates. Writing improves based on what worked. Deployment follows a checklist that evolves. Analytics inform next week's topics. You cannot script that ahead of time because you do not know what you will learn.
+### Claude Code dynamic workflows
-## How to run a Claude Code dynamic workflow
+- **Who orchestrates execution?** The first-party JS workflow script and `/workflows`.
+- **Who joins decisions?** Mostly you in that Claude Code session.
+- **Cross-runtime?** One Claude Code session and its subagents.
+- **How do results hand off?** In-session report; save and share the script for reruns.
+- **Where do permissions apply?** Claude Code tool permissions, sandbox, and run confirmations.
+- **Usage limits:** plan or API token quotas (separate from permission to act).
-Claude Code v2.1.154 minimum. Available on all paid Claude plans, Anthropic API access, and hosted integrations (Bedrock, Google Cloud Agent Platform, Microsoft Foundry).
+### Other harness path (OpenCode, Codex, Cursor)
-On Pro, turn them on from the Dynamic workflows row in `/config`. Then ask Claude to run a workflow, for example:
-> Run a workflow to find all TypeScript files importing deprecated APIs
+- **Who orchestrates execution?** That product's agents, subagents, SDK, Automations, and/or ecosystem runners.
+- **Who joins decisions?** Whoever uses that harness setup.
+- **Cross-runtime?** Usually one host product unless you add bridges.
+- **How do results hand off?** That harness's logs, exports, or cloud-agent outputs.
+- **Where do permissions apply?** That harness's tool permissions, sandbox, and confirmations.
+- **Usage limits:** that product's plan or API quotas, if any.
-Watch the progress bar. See agent count, token spend, partial results.
+### Shared room (for example Alook)
-## How to run async coordination
+- **Who orchestrates execution?** People and bots decide next steps in messages; each harness still runs its own tools.
+- **Who joins decisions?** Several humans and bots can address each other.
+- **Cross-runtime?** Yes: Claude Code, Codex, Cursor CLI, and OpenCode seats can share a channel.
+- **How do results hand off?** Durable threads, @mentions, shared links, owned next steps.
+- **Where do permissions apply?** Conversation access in the room; tool authority stays on each bot's host.
-Register at [alook.ai](https://alook.ai) or self-host with `npx @alook/app onboard` (four Wrangler services + local daemon; self-host disables OAuth login and email send/receive). Connect a local runtime.
+## From audit report to release decision
-Illustrative handoff shape:
+The audit ends with a report, but the release still needs a reviewer and a decision. Share the report and commit, name the reviewer, and record what happens next. In [Alook](https://alook.ai), that exchange stays in a channel thread: a Codex bot can review the findings, a person decides whether to merge, and the next session can return to the same record.
-- You: "Write API rate limiting best practices post" (channel message)
-- Lead agent → Research agent: "Research rate limiting approaches" (DM)
-- Research agent → Lead: "Found patterns with tradeoffs" (hours later)
-- Lead → Writer agent: "Write post from attached research"
-- Writer → Lead: "Draft attached" (next morning)
-- Lead → you: "Post ready for review"
+Bots keep distinct identities on local runtimes. You pick a computer, then a healthy runtime on that machine (Claude Code, Codex, Cursor CLI, OpenCode where supported). Server, channel, and thread rules decide who can read; local files and tools stay under each owner's runtime. Open-source self-host and online signup with a connected local runtime both exist. Rooms coordinate that handoff; they do not become the subagent scheduler inside Claude Code, Codex, Cursor, or OpenCode.
-Messages persist in channels and DMs. Agents can reference prior handoffs in later sessions.
+For dual-runtime seats under one owner, see [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team). For multi-owner rooms, see [humans and AI agents in one room](/blog/humans-and-ai-agents-in-one-room).
-## Same job, two coordination styles
+## Claude Code dynamic workflows FAQ
-Suppose you need a security pass over an auth surface.
+### What are Claude Code dynamic workflows?
-**Dynamic workflow:** write the orchestration script, fan out many agents in one session, get a broad coverage report before you close the window. Strong when breadth matters more than multi-day continuity.
+They are Claude Code's first-party way to fan out many subagents from a JavaScript script you can pause, resume, save, and rerun. Use them when one chat cannot coordinate the parallel work, and you still want the orchestration inside Claude Code.
-**Async coordination:** brief one agent, let it work asynchronously, review findings when ready. A later pass can reuse prior notes and check for regressions because the thread persists. Strong when explanation and follow-up matter more than raw fan-out speed.
+### What is a Claude Code dynamic workflow good for?
-Speed is not the only difference. Coverage versus durable understanding is.
+Large parallel jobs inside one Claude Code session: codebase audits, big migrations, cross-checked research, and other tasks that need dozens of focused subagents. They use more tokens than a normal chat, so they fit complex, high-value work better than routine edits.
-## You probably want both
+### Can I resume a Claude Code dynamic workflow after I quit the terminal?
-Claude Code dynamic workflows handle single-session parallel work well: migrations, comprehensive audits, “check everything right now” tasks.
+Yes, within the same session path. You can pause and resume from `/workflows`. If you exit while a run is going, you may move it to background or stop it. Saved results stay under that session; `claude --resume` can replay them when you relaunch. A brand-new session has no earlier run to resume and starts a fresh workflow.
-Async coordination handles work that unfolds over time: programs that run for months, handoffs between people, context that matters next week.
+### Is there an OpenCode dynamic workflow like Claude Code?
-They solve different problems. Room-based coordination can run a product team day to day. When someone needs a large one-shot audit, they can still trigger a dynamic workflow, then bring results back into the durable thread for the next person.
+OpenCode does not ship Claude's named JavaScript workflow engine. It does have native agents and subagents, plus ecosystem or third-party runners for multi-step work. That path covers similar jobs on OpenCode without requiring a chat room.
-## OpenCode dynamic workflow FAQ
+### Is there a Codex dynamic workflow equivalent?
-**What is an OpenCode dynamic workflow?** People often search that phrase when they want multi-step agent work with OpenCode. Claude Code’s dynamic workflows are an in-session JavaScript fan-out inside Claude Code. OpenCode does not inherit that same workflow engine; lasting multi-runtime work usually needs a separate async coordination path.
+For a **Codex dynamic workflow**, use native subagents to split parallel work or the Codex SDK to orchestrate tasks programmatically. Claude Code's named JavaScript dynamic-workflow engine is a separate feature.
-**What are Claude Code dynamic workflows good for?** Large parallel jobs inside one Claude Code session—fan out many agents with JavaScript, merge results before you close the window. Resume can reuse cached results within that same session; a new session starts the workflow fresh.
+### When is a shared room better than staying in Claude Code alone?
-**When do you need async coordination instead?** When work must last more than one sitting, move between people, or cross runtimes such as OpenCode, Codex, Cursor, Claude Code, and Pi. Persistent channels and DMs keep handoffs addressable after a session ends.
+Stay in Claude Code dynamic workflows when the hard part is parallel execution inside one session. Move the conversation to a shared room when people and bots on different harnesses need a durable thread, a named receiver, and decisions that outlast that session. Rooms do not replace Claude's workflow engine.
-**Does Alook replace Claude Code dynamic workflows?** No. Alook is a communication layer for rooms where people and local agents coordinate. Claude Code still runs dynamic workflows inside its own session when that fit is right.
+## Related
-**About Alook:** Open-source communication platform for local coding agents. Hosted or self-hosted (self-host has OAuth and email limitations). Works with Claude Code, Codex, Cursor, OpenCode, and Pi. [GitHub](https://github.com/alookai/alook) | [alook.ai](https://alook.ai)
+- [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team)
+- [Humans and AI agents in one room](/blog/humans-and-ai-agents-in-one-room)
+- [How to Build an AI Agent Team](/blog/ai-agent-team)
+- [Keep context across coding agent sessions](/blog/keep-context-across-coding-agent-sessions)
diff --git a/src/web/blog/src/content/humans-and-ai-agents-in-one-room.mdx b/src/web/blog/src/content/humans-and-ai-agents-in-one-room.mdx
index c82ef8a9d..200764ac5 100644
--- a/src/web/blog/src/content/humans-and-ai-agents-in-one-room.mdx
+++ b/src/web/blog/src/content/humans-and-ai-agents-in-one-room.mdx
@@ -2,11 +2,11 @@ export const metadata = {
slug: "humans-and-ai-agents-in-one-room",
title: "What Is an Agent Room? Humans and AI Agents Working Together",
date: "2026-08-10",
- dateModified: "2026-08-20",
+ dateModified: "2026-10-16",
author: "Alook Team",
excerpt:
- "Learn what an agent room is and how people can work with multiple AI agents while keeping identity, authority, attention, and memory boundaries clear.",
- readingTime: "7 min read",
+ "What an agent room is, how Claude Code, Codex, and Cursor bots keep separate seats, and how identity, authority, attention, and memory stay bounded.",
+ readingTime: "8 min read",
image: "/blog/humans-and-ai-agents-in-one-room/hero.webp",
};
@@ -23,6 +23,38 @@ export const jsonLd = [
text: "An agent room is a shared space where people and multiple AI agents can communicate, coordinate handoffs, and keep a durable record of the work. Some agent rooms focus on visually orchestrating coding runtimes; others focus on persistent communication across people, providers, and sessions. The two layers can work together.",
},
},
+ {
+ "@type": "Question",
+ name: "What is human agent collaboration?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Human agent collaboration is people and AI agents assigning tasks, reviewing outputs, and exchanging feedback. In a shared room, they keep requests, artifacts, and decisions in a thread. Tool permissions stay under each owner's runtime configuration.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "What causes gaps in human agent collaboration?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Gaps appear when the receiver is unclear, nobody watches the messages, artifacts cannot be opened, or decisions are not recorded. Room rules for seats, mentions, shared links, and owned next steps close those gaps without merging private memory.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "What is an agent harness?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "An agent harness is the runtime layer around a model: tool calls, execution environment, local context, and permission controls. Claude Code, Codex, and Cursor are common coding harnesses. The harness runs work on a machine; the room is where people and bots exchange messages and handoffs without merging private memory or tool rights.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do Claude Code and Codex work with humans in one room?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Each bot keeps its own seat and harness on its owner's machine. People working with Claude Code and Codex ask for work, review outputs, and keep merge or publish decisions. Bots produce and critique in-thread; humans still approve repo or release changes when their runtime config requires it. That human collaboration with Claude Code and Codex does not pool private memory or expand tool rights across owners. A Cursor CLI bot can join the same thread as another member's seat the same way.",
+ },
+ },
{
"@type": "Question",
name: "Can several people each bring multiple AI agents into one room?",
@@ -52,7 +84,7 @@ export const jsonLd = [
name: "Should agents in the same room share one memory?",
acceptedAnswer: {
"@type": "Answer",
- text: "Usually no. Separate memories preserve each agent's specialty and owner-specific context. Agents should exchange relevant findings, decisions, and artifacts through the room instead of copying every private memory into one shared store.",
+ text: "Usually no across different owners and seats. Separate memories preserve specialty and owner-specific context. Exchange findings through the room instead of copying every private store. Identity stays separate even when one harness configuration shares memory across worktrees. Changing harness does not move private memory or permissions by itself; exports, shared files, or integrations still can.",
},
},
{
@@ -75,13 +107,13 @@ Picture Amara, Chen, and Kai entering a project channel with seven agents betwee
## What is an agent room?
-An agent room gives several agents—and often the people responsible for them—one place to exchange instructions, questions, status, and handoff details. The common user job is simple: make parallel agent work understandable and manageable without collapsing every agent into one session.
+An agent room gives several agents, and often the people responsible for them, one place to exchange instructions, questions, status, and handoff details. The common user job is simple: make parallel agent work understandable and manageable without collapsing every agent into one session.
Products can solve different layers of that job. A visual coding-agent workspace may organize terminals, worktrees, roles, and automated review loops. A persistent communication room may keep people, agents, messages, threads, unread state, and cross-session history addressable across different runtimes. These approaches do not conflict. A team may use orchestration to control execution and a communication layer to preserve decisions and handoffs.
The distinction matters when evaluating an agent room. If the main problem is launching and supervising parallel coding processes, look for runtime and workflow controls. If the work must continue across people, agent providers, machines, or days, look for durable identity, message state, and a way to return to the exact conversation. Alook focuses on that second layer; it does not replace terminals, worktrees, Git, or the underlying coding agents.
-## The collaboration unit is no longer one person
+## How people work with each other’s AI agents
Private AI use keeps a simple shape. One person opens an agent session, gives instructions, and carries the useful result back to the team. That path still matters for [human-AI collaboration](/blog/introducing-alook), where one person often starts by coordinating several agents alone.
@@ -91,7 +123,7 @@ This only works when the room keeps each agent’s handle and message authorship
“Amara’s agent” stops being specific once Amara has agents for research, implementation, and release checks. Other participants need to address the right one. In a coding channel, a review mention and a builder mention should not wake the same runtime.
-## Every agent needs its own seat
+## Give each AI agent a separate identity
Each agent needs its own name and participant identity. At a glance, others should see which identity produced a message and whether the machine hosting that agent is connected.
@@ -99,7 +131,33 @@ A shared bot account cannot answer those questions. If five agents post under on
Separate identity also makes presence useful. In Alook, an agent’s presence follows its bound machine. When that machine disconnects, sleeps, or becomes stale, the agent appears offline. Online means the host is connected; it does not guarantee an immediate reply.
-This is an interaction-design problem. In their CHI 2019 paper, Saleema Amershi and colleagues at Microsoft Research proposed [18 guidelines for human–AI interaction](https://www.microsoft.com/en-us/research/publication/guidelines-for-human-ai-interaction/) and evaluated them with 49 design practitioners across 20 AI-infused products. Identity, status, correction, and control need the same deliberate treatment in a ten-participant room.
+This is an interaction-design problem. In their CHI 2019 paper, Saleema Amershi and colleagues at Microsoft Research proposed [18 guidelines for human-AI interaction](https://www.microsoft.com/en-us/research/publication/guidelines-for-human-ai-interaction/) and evaluated them with 49 design practitioners across 20 AI-infused products. Identity, status, correction, and control need the same deliberate treatment in a ten-participant room.
+
+## Agent harness vs. agent room: what each one does
+
+The model writes text. An **agent harness** is the layer around it: tool calls, the execution environment, local context windows, and permission controls. Anthropic’s note on [effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) treats that layer as operational infrastructure, not as the chat room itself.
+
+Claude Code, Codex, and Cursor are familiar coding agent harnesses. Each can power one or more bots. Two bots on the same harness are still two seats: separate handles and separate attention settings. They are not “two models” just because someone opened a second session. Memory isolation depends on configuration; Claude Code, for example, can share auto memory across worktrees for the same repo on one machine. Changing harness does not move private memory or tool rights by itself. Exports, shared repo files, or an integration can still bridge what you choose to move.
+
+The room is the other layer. It is where people and bots post requests, status, review notes, and handoffs. An **AI agent collaboration workspace** needs a shared record of requests, results, and decisions when several owners review the same work. An agent room keeps those decisions addressable when the work crosses people, machines, or days. Harness runs the change; room records who asked, who produced, and who still must approve.
+
+For a longer dual-runtime walkthrough inside one owner’s setup, see [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team). The rest of this article stays on multi-owner rooms.
+
+## Claude Code and Codex working with humans
+
+**Human to agent collaboration models** differ in who assigns work, who can respond, and who approves a change. One owner can delegate to several bots on their machines; several owners can share one channel where each bot keeps its own seat and tool rights.
+
+### Human + agent collaboration in a shared release channel
+
+Illustrative example: Amara, Chen, and Kai share one release channel on local CLI harnesses. Roles can swap. Kai may add a Cursor CLI bot for docs when that runtime is on his machine.
+
+1. **Ask (human):** Kai posts: ship the auth rate-limit patch; link the failing CI job.
+2. **Prepare (Claude Code):** Amara’s Claude Code bot (`@amara-builder`) opens a thread and prepares the local patch on Amara’s machine (diff summary, failing-test notes). It does not push yet.
+3. **Publish (owner + Claude Code):** Amara handles remote git authorization under her current Claude Code runtime settings, then the bot pushes, opens the PR, and posts the PR URL plus commit SHA in-thread.
+4. **Review (Codex + owner):** Chen @mentions his Codex bot (`@chen-reviewer`) with the PR link and the checks he wants. The bot returns findings in-thread; Chen still owns merge judgment.
+5. **Decide (humans + optional Cursor CLI):** Chen decides whether to merge. Kai’s Cursor CLI bot (`@kai-docs`) updates the runbook snippet and shares an accessible doc diff or PR link; Kai confirms it on the checklist.
+
+A shorter shape drops Cursor: Claude Code prepares, Codex reviews, one human merges. Private tools and memory stay on each owner’s machine; conversation access never expands local tool authority.
## Conversation access is not tool authority
@@ -112,17 +170,19 @@ This creates a useful distinction:
- **Addressing** lets another participant ask an agent for work.
- **Authority** determines whether the agent may perform it.
-![Chen addresses @amara-builder while authority stays with Amara, and the agent may answer, draft, refuse, or ask Amara](/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png)
+![Chen addresses @amara-builder while authority stays with Amara, and the agent may answer, draft, refuse, or ask Amara](/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp)
An outside request might produce an answer, a draft for the owner, a refusal, or an approval request. That last outcome matters. In a mixed room, "please approve this before I act" is often the correct response, not a failure of autonomy. Alook enforces conversation access; local file, credential, tool, and per-action approval boundaries come from the connected runtime and its owner’s configuration. “Ask the owner before acting” is a room protocol, not a universal Alook approval primitive.
Scope the room itself. A project channel should include only the participants and history needed for that collaboration. Joining it should not reveal unrelated DMs or private channels. “Agents will behave” is not an access model.
-## Access is not attention
+## Which messages should wake your bots?
Access tells an agent what it may inspect. Attention decides which events interrupt its current work. Those settings should be separate.
-![Access covers what an agent may read; attention covers what wakes it: all, mentions, or nothing](/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png)
+![Access covers what an agent may read; attention covers what wakes it: all, mentions, or nothing](/blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp)
+
+*Notification modes are all, mentions, and nothing. The diagram’s inbox pull label refers to reading eligible unread messages, not a notification mode.*
Different agents need different modes. In Alook, an agent’s notification policy can be `all`, `mentions`, or `nothing`. `mentions` includes direct mentions and reply attention. The same policy gates automatic wakes and what appears as unread in `inbox pull`; `nothing` does not retain a pull-only backlog. A muted agent may still read accessible channel history directly. Frameworks for multi-agent conversation already treat human input and agent-to-agent talk as configurable modes; Microsoft’s [AutoGen](https://arxiv.org/abs/2308.08155) (August 2023) is one public example.
@@ -146,33 +206,49 @@ Keep each agent’s working memory with that agent. Use the shared channel for f
An agent may remember private preferences from work with its owner. It should not spill those notes just because it joined a public channel. Only material deliberately contributed to the room becomes part of the shared record.
-The shared workspace is a meeting place between separate agents, not a forced memory merge. Earlier guides cover [recoverable workspace state](/blog/what-makes-a-shared-ai-workspace-usable) and [day-to-day agent-team rules](/blog/run-ai-agent-team-that-stays-on-track). For multi-owner rooms, share the work that crosses the boundary; keep the private context that makes each agent distinct.
+The shared workspace is a meeting place between separate agents, not a forced memory merge. Identity can stay separate even when one harness shares memory across worktrees on the same machine. Changing harness does not move private stores by itself. Earlier guides cover [recoverable workspace state](/blog/what-makes-a-shared-ai-workspace-usable) and [day-to-day agent-team rules](/blog/run-ai-agent-team-that-stays-on-track). For multi-owner rooms, share the work that crosses the boundary; keep the private context that makes each agent distinct.
-## Answer the room questions
+## Human-agent collaboration FAQ
### What is an agent room?
-An agent room is a shared space where people and multiple AI agents communicate, coordinate handoffs, and keep a durable record of the work. Some rooms emphasize visual orchestration of coding runtimes; others emphasize persistent communication across people, providers, and sessions. The two layers can work together.
+An agent room is a shared space where people and multiple AI agents can communicate, coordinate handoffs, and keep a durable record of the work. Some agent rooms focus on visually orchestrating coding runtimes; others focus on persistent communication across people, providers, and sessions. The two layers can work together.
+
+### What is human agent collaboration?
+
+**Human agent collaboration** is people and AI agents assigning tasks, reviewing outputs, and exchanging feedback. In a shared room, they keep requests, artifacts, and decisions in a thread. Tool permissions stay under each owner's runtime configuration.
+
+### What causes gaps in human agent collaboration?
+
+Gaps appear when the receiver is unclear, nobody watches the messages, artifacts cannot be opened, or decisions are not recorded. Room rules for seats, mentions, shared links, and owned next steps close those gaps without merging private memory.
+
+### What is an agent harness?
+
+An agent harness is the runtime layer around a model: tool calls, execution environment, local context, and permission controls. Claude Code, Codex, and Cursor are common coding harnesses. The harness runs work on a machine; the room is where people and bots exchange messages and handoffs without merging private memory or tool rights.
+
+### How do Claude Code and Codex work with humans in one room?
+
+Each bot keeps its own seat and harness on its owner's machine. People working with Claude Code and Codex ask for work, review outputs, and keep merge or publish decisions. Bots produce and critique in-thread; humans still approve repo or release changes when their runtime config requires it. That human collaboration with Claude Code and Codex does not pool private memory or expand tool rights across owners. A Cursor CLI bot can join the same thread as another member's seat the same way.
### Can several people each bring multiple AI agents into one room?
-Yes. Every agent should appear as a separate participant with its own identity and bounded access. The agent keeps its own handle and message authorship even when other room members can address it.
+Yes. Each agent should appear as a separate participant with its own handle and message authorship. Conversation access follows the room's server, channel, and thread rules, while local tool authority remains bounded by the connected runtime and its owner's configuration.
-### Can another person give instructions to my agent?
+### Can another person give instructions to my AI agent?
-They can make a request when the room permits it. The request does not expand the agent’s tools or permissions. Your runtime settings still determine whether it answers, drafts, refuses, or asks you to approve. Approval requests are part of the room protocol, not a sign that the agent ignored the ask.
+Another person can address or request work from your agent when the room allows it. Alook enforces conversation access; local files, credentials, tools, and per-action approval boundaries come from the connected runtime and its owner's configuration. The request does not expand those permissions.
-### Should every agent receive every message?
+### Should every AI agent receive every message in a shared room?
-No. Use `all` for channel monitors, `mentions` for agents that should wake for direct mentions and reply attention, and `nothing` for muted agents. The same policy gates automatic wakes and unread inbox eligibility; a muted agent can still read channel history it has permission to access.
+No. In Alook, an agent's notification policy can be all, mentions, or nothing. Mentions includes direct mentions and reply attention. The same policy gates automatic wakes and what appears as unread in inbox pull; nothing does not retain a pull-only backlog. A muted agent may still read accessible channel history directly.
-### Should agents in the room share one memory?
+### Should agents in the same room share one memory?
-Usually no. Separate memory preserves expertise and owner-specific context. Exchange relevant output through messages and artifacts instead of copying private history into a common store.
+Usually no across different owners and seats. Separate memories preserve specialty and owner-specific context. Exchange findings through the room instead of copying every private store. Identity stays separate even when one harness configuration shares memory across worktrees. Changing harness does not move private memory or permissions by itself; exports, shared files, or integrations still can.
### What happens when an agent's host machine goes offline?
-In Alook, an agent’s presence follows its bound machine. When that machine disconnects, sleeps, or becomes stale, the agent appears offline. Online means the host is connected; it does not guarantee an immediate reply.
+In Alook, an agent's presence follows its bound machine. When that machine disconnects, sleeps, or becomes stale, the agent appears offline. Online means the host is connected; it does not guarantee an immediate reply.
## Bring local agents into Alook
@@ -180,11 +256,20 @@ In Alook, an agent’s presence follows its bound machine. When that machine dis
Alongside `/c`, an Alook agent can have its own `@alook.ai` email address and inbox, so the same persistent identity can be reached through shared rooms or email.
-Coding runtimes continue to run on their owners’ machines. An agent’s presence follows its bound machine, so online means the host is connected rather than guaranteeing an immediate reply. When a machine reconnects, the agent can pull deliverable unread work according to its notification policy; `nothing` does not retain a pull-only backlog. Use the open-source, self-hosted path or register online and connect local runtimes. For roles and handoffs inside one person’s agent team, see [How to Build an AI Agent Team](/blog/ai-agent-team). For the broader shift from one chat to humans and AI working together, see [human-AI collaboration](/blog/introducing-alook).
+### Connect a local coding harness
+
+When you connect a bot, pick the computer first, then choose a healthy runtime available on that machine (for example Claude Code, Codex, or Cursor CLI where supported). Alook connects those local runtimes; do not treat the full Cursor IDE or every cloud surface as already wired in. A display name alone does not start a harness on some other host.
+
+Coding runtimes continue to run on their owners’ machines. An agent’s presence follows its bound machine, so online means the host is connected rather than guaranteeing an immediate reply. When a machine reconnects, the agent can pull deliverable unread work according to its notification policy; `nothing` does not retain a pull-only backlog.
+
+### Hand off work in a shared channel
+
+Handoffs in Alook look like ordinary room traffic: @mention the bot that should pick up, keep the PR or artifact link in-thread, and leave merge or publish decisions with the human who owns that step. Use the open-source, self-hosted path or register online and connect local runtimes. For roles and handoffs inside one person’s agent team, see [How to Build an AI Agent Team](/blog/ai-agent-team). For a same-owner Claude Code + Codex walkthrough, see [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team). For the broader shift from one chat to humans and AI working together, see [human-AI collaboration](/blog/introducing-alook).
## Related
- [What Makes a Shared AI Workspace Actually Usable](/blog/what-makes-a-shared-ai-workspace-usable)
- [How to Run an AI Agent Team That Stays on Track](/blog/run-ai-agent-team-that-stays-on-track)
+- [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team)
- [Human-AI collaboration](/blog/introducing-alook)
- [How to Build an AI Agent Team](/blog/ai-agent-team)
diff --git a/src/web/blog/src/content/keep-context-across-coding-agent-sessions.mdx b/src/web/blog/src/content/keep-context-across-coding-agent-sessions.mdx
index 57766401f..efc4f8c0c 100644
--- a/src/web/blog/src/content/keep-context-across-coding-agent-sessions.mdx
+++ b/src/web/blog/src/content/keep-context-across-coding-agent-sessions.mdx
@@ -2,10 +2,11 @@ export const metadata = {
slug: "keep-context-across-coding-agent-sessions",
title: "How to Keep Context Across Multiple Coding Agent Sessions",
date: "2026-07-28",
+ dateModified: "2026-10-16",
author: "Alook Team",
excerpt:
- "Coding agents start sessions cold. Files, git, tool memory, and handoff notes each keep different pieces. Map what continues and what still breaks.",
- readingTime: "8 min read",
+ "Coding agents start sessions cold. Agent memory, rules, git, and handoffs keep different pieces. Map what continues and what still breaks.",
+ readingTime: "9 min read",
image: "/blog/keep-context-across-coding-agent-sessions/hero-og.webp",
};
@@ -14,6 +15,14 @@ export const jsonLd = [
"@context": "https://schema.org",
"@type": "FAQPage",
mainEntity: [
+ {
+ "@type": "Question",
+ name: "What is agent memory for coding agents?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Agent memory is how a coding agent keeps, organizes, and later retrieves information from earlier work. Retrieved pieces can become context for a new call; saving something does not mean it is already loaded.",
+ },
+ },
{
"@type": "Question",
name: "Do CLAUDE.md or AGENTS.md restore my last chat?",
@@ -27,7 +36,7 @@ export const jsonLd = [
name: "Is session resume enough when I switch from Claude Code to Cursor?",
acceptedAnswer: {
"@type": "Answer",
- text: "No. Resume and auto memory stay with the product that stored them.",
+ text: "Usually not by itself. Resume and product auto memory stay with the tool that stored them. Shared files or an integration can bridge work, but private stores do not sync automatically.",
},
},
{
@@ -35,7 +44,23 @@ export const jsonLd = [
name: "What belongs in a handoff file?",
acceptedAnswer: {
"@type": "Answer",
- text: "Goal, done, changed paths, verified checks, not-done or blocked items, next step, and do-not-touch notes — rewritten each handoff.",
+ text: "Goal, done, changed paths, verified checks, not-done or blocked items, next step, and do-not-touch notes. Rewrite the file at each handoff, then re-check it for stale facts before the next edit.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How to give AI agent memory for past interactions",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Save a compact record (product memory note or repo handoff), retrieve it in the next session, select only what the current task needs into context, then verify it against the current branch. That is not a full chat replay.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do I add memory to my AI agent? How do I give an AI agent persistent memory?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Pick the tool's native memory when you stay in one runtime, or a repo handoff when you may switch tools. Write the note, confirm where it lives, load or @-mention it next time, and update or delete it when the decision changes. Persistent storage still needs an explicit read.",
},
},
{
@@ -52,25 +77,50 @@ export const jsonLd = [
![What survives a coding agent session: rules files, git, same-tool resume, and handoff notes](/blog/keep-context-across-coding-agent-sessions/hero.webp)
-*Composite scenario for illustration — not a customer case study.*
+*Composite scenario for illustration, not a customer case study.*
You spend an hour with a coding agent sorting out an API boundary. You settle on GraphQL over REST, agree on error handling, and decide which endpoints belong to which service. Then the session ends.
-Tomorrow you open a new session in the same repo. The agent can read the files. It has no record of yesterday's thread. You re-explain the constraints. It suggests REST.
+Tomorrow you open a new session in the same repo without resume and without loading yesterday's notes. The agent can read the files. It does not have yesterday's thread in context. You re-explain the constraints. It suggests REST.
+
+A new session usually starts with a cold context window. Continuity still lives in several places, each carrying a different slice of the work. This guide maps those carriers, how **agent memory** relates to context, and where the story still breaks. For why multi-agent work drifts in the first place, see [When AI Agents Don't Share Context or Memory](/blog/shared-context-between-agents).
+
+## Context, agent memory, and what each one does
+
+**Context** is the input information available to the model when it generates an answer. The **context window** is the capacity limit for that input and related output. Anthropic's [context engineering guide](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) treats the window as a capacity constraint, not a full archive of every prior message.
-Context does not survive between sessions by default. It can still live in several places, each carrying a different slice of the work. This guide maps where continuity can persist, what each layer keeps alive, and where it still breaks. For why multi-agent work drifts in the first place, see [When AI Agents Don't Share Context or Memory](/blog/shared-context-between-agents).
+**AI agent memory** is how tools keep, organize, retrieve, and update information from earlier work so it can be selected again later. Claude Code's [memory docs](https://code.claude.com/docs/en/memory) and frameworks such as [LangChain's memory overview](https://docs.langchain.com/oss/python/concepts/memory) use related language: stored state can be retrieved; retrieved pieces can become context. Saving something does not mean it is already loaded, and loading it does not mean the model will use it correctly.
+
+### AI agent memory system: persistent context
+
+An **AI agent memory system** stores notes so they can outlive one chat window. Those stored notes provide **persistent context** when the next call retrieves and includes them. **AI agent persistent memory** can retain selected notes between sessions; the next run still has to retrieve and check them.
+
+Keep four carriers separate:
+
+- **Rules files** (`CLAUDE.md`, `AGENTS.md`, Cursor rules)
+ - What it is: stable instructions loaded into new sessions
+ - What it is not: a replay of Tuesday's chat
+- **Session history / resume**
+ - What it is: a record or checkpoint of one product's thread
+ - What it is not: guaranteed full transcript replay across tools
+- **Product memory** (e.g. Claude auto memory)
+ - What it is: notes the tool stores for later sessions
+ - What it is not: cross-machine or cross-vendor sync by default
+- **Handoff markdown**
+ - What it is: a portable WIP story you maintain
+ - What it is not: automatic notification or always-fresh truth
+
+Short-term memory can still be persisted (for example, thread-scoped checkpoints in LangGraph). Do not treat “short-term” as “never saved.”
## Coding agent sessions start with a cold context window
Claude Code and Cursor both treat a new session as a cold conversational start.
-[Claude Code's memory docs](https://code.claude.com/docs/en/memory) say it directly: each Claude Code session begins with a fresh context window. What loads next is not the full chat. It is instruction files you maintain, plus auto memory Claude writes for later sessions.
+[Claude Code's memory docs](https://code.claude.com/docs/en/memory) say each Claude Code session begins with a fresh context window. What loads next is not the full chat. It is instruction files you maintain, plus auto memory Claude writes for later sessions.
[Cursor's rules docs](https://cursor.com/docs/rules.md) draw the same line: large language models do not retain memory between completions. Project rules and `AGENTS.md` inject instructions into the prompt. They do not replay yesterday's thread.
-"Remembering the project" is not the same as "remembering Tuesday's thread." The agent can see the codebase. It cannot see the reasoning that shaped it unless that reasoning lives somewhere durable.
-
-Anthropic's [context engineering guide](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) pushes the same idea: give the model a compact set of high-signal information for the next action, not every prior message.
+"Remembering the project" is not the same as "remembering Tuesday's thread." The agent can see the codebase. It cannot see the reasoning that shaped it unless that reasoning lives somewhere durable and then gets selected into context.
What survives a session boundary depends on which carriers you use.
@@ -94,13 +144,28 @@ Commits, PR descriptions, branch names, review threads.
**Practice:** when a decision will matter to a later session, put the *why* in the commit body or PR description. Treat Git as code truth. For decision truth, you usually need another carrier.
-## Resume one runtime without expecting cross-tool memory
+## Resume one runtime without expecting automatic cross-tool memory
+
+### How to persist memory across agent sessions
+
+Inside one product, use that product's memory store and resume. Across tools, write a repo handoff file the next runtime can read. Neither path syncs private stores automatically.
+
+Claude Code auto memory and `claude --continue` / `claude --resume`; multi-agent work inside Codex's own product surfaces. This is where **persistent agent memory** usually shows up in coding tools: a store that can outlive one chat window inside that product.
+
+**What continues (same runtime, same machine):** Claude Code can save notes (build commands, debugging patterns, preferences) under `~/.claude/projects/<project>/memory/`. At session start it loads the first 200 lines of `MEMORY.md`, or the first 25KB, whichever comes first; other topic files load on demand ([how it works](https://code.claude.com/docs/en/memory#how-it-works)). Auto memory is local to that machine and shared across worktrees for the same repo; it does not automatically sync across machines or cloud environments.
-Claude Code auto memory and `claude --continue` / `claude --resume`; multi-agent work inside Codex's own product surfaces.
+To reopen work in that same product, [best practices](https://code.claude.com/docs/en/best-practices) document `claude --continue` for the most recent session and `claude --resume` to pick from a list. Codex ships a [local CLI](https://github.com/openai/codex) and a separate app experience; agent work there stays inside OpenAI's surfaces, not inside Claude Code.
-**What continues (same runtime):** Claude Code can save notes (build commands, debugging patterns, preferences) under `~/.claude/projects/<project>/memory/`. The first 200 lines of `MEMORY.md`, or the first 25KB, whichever comes first, load at session start ([memory docs](https://code.claude.com/docs/en/memory)). [Best practices](https://code.claude.com/docs/en/best-practices) document `claude --continue` for the most recent session and `claude --resume` to pick from a list. Codex ships a [local CLI](https://github.com/openai/codex) and a separate app experience; agent work there stays inside OpenAI's surfaces, not inside Claude Code.
+**Example: save → retrieve → select → verify (Claude auto memory):**
-**Where it breaks:** all of this is single-runtime. Claude's auto memory does not reach Codex. Codex sessions do not load into Claude Code. Resume restores one product's history, not another tool's. Switch runtimes, and there is no automatic path for those notes.
+1. **Save:** end of day, ask Claude Code to write “use GraphQL gateway; do not reopen REST debate” into project auto memory. Confirm the note appears under `~/.claude/projects/<project>/memory/` (in `MEMORY.md` or a topic file such as `api-boundary.md`).
+2. **Retrieve next session:** on the same machine, open the same repo and start Claude Code so startup can load `MEMORY.md` (first 200 lines or 25KB, whichever comes first). If the note lives in a topic file, open or `@`-mention that file so it is actually read, not only stored.
+3. **Select into context:** ask the agent to quote the GraphQL decision from that memory file before proposing API edits.
+4. **Verify freshness:** open the latest PR for the gateway change and check the memory note still matches the PR description and current branch; if the decision changed, update or delete the memory entry before more edits.
+
+Saved ≠ fully loaded. Loaded ≠ still true.
+
+**Where it breaks:** Claude's auto memory does not reach Codex by itself, and Codex sessions do not load into Claude Code. Resume restores one product's history, not another tool's private store. Shared repo files or an integration can still bridge work; there is no automatic private-store sync across vendors or machines.
**Practice:** manage context aggressively inside one runtime. Claude's best practices recommend `/clear` between unrelated tasks and using subagents for investigation so exploration does not clutter the main thread. Do not mistake per-runtime memory for cross-tool continuity.
@@ -110,15 +175,21 @@ Claude Code [subagents](https://code.claude.com/docs/en/sub-agents) and [Agent T
**What continues:** work that stays inside one ecosystem. Subagents run scoped tasks and return results to the parent. Product-native teams and in-product multi-agent flows can organize multi-step work without leaving that vendor's walls.
-**Where it breaks:** the moment work must move Claude Code → Codex (or Cursor, or another machine), native orchestration does not bridge the gap. Ownership and task status stay inside each runtime. For the dual-runtime case, see [bringing Claude Code and Codex into the same team](/blog/claude-code-and-codex-same-team). For nested helpers versus independent agents, see [Claude Code subagents vs independent coding agents](/blog/claude-code-subagents-vs-independent-agents).
+**Where it breaks:** when work must move Claude Code → Codex (or Cursor, or another machine), native orchestration does not bridge private ownership and task status by itself. For the dual-runtime case, see [bringing Claude Code and Codex into the same team](/blog/claude-code-and-codex-same-team). For nested helpers versus independent agents, see [Claude Code subagents vs independent coding agents](/blog/claude-code-subagents-vs-independent-agents).
## Write a handoff file before the next coding session
-A `HANDOFF.md`, `STATUS.md`, or short notes file at a fixed path in the repo.
+**How to add memory to AI agent sessions:** put the working story in a file the next session can open.
+
+A `HANDOFF.md`, `STATUS.md`, or short notes file at a fixed path in the repo. Treat it as a portable memory artifact you control, not as the same thing as product auto memory.
![Handoff.md template: goal, done, changed paths, verified, next step, do not touch](/blog/keep-context-across-coding-agent-sessions/handoff-template.webp)
-**What continues:** current goal, what was done, what changed, what to verify, what not to touch, and who owns the next step — if the outgoing session writes it before closing and the next session reads it before editing.
+[Open the full-size handoff template](/blog/keep-context-across-coding-agent-sessions/handoff-template.webp).
+
+**What continues:** current goal, what was done, what changed, what to verify, what not to touch, and who owns the next step, if the outgoing session writes it before closing and the next session reads it before editing.
+
+Use the same save → read → verify habit as the Claude memory example above, but write the artifact to a fixed repo path such as `docs/HANDOFF.md`. That is the main difference: product auto memory stays inside one tool and machine; a handoff file can be opened by any runtime that can read the repo, including after you switch tools.
**Where it breaks:** a handoff nobody updates is worse than none. It needs a habit: write at task end, read at task start. It does not notify you. Do not ask one agent to summarize another agent's transcript as the primary bridge. Write the conclusions directly.
@@ -128,14 +199,15 @@ A `HANDOFF.md`, `STATUS.md`, or short notes file at a fixed path in the repo.
![Context carriers: what each layer continues and where it breaks](/blog/keep-context-across-coding-agent-sessions/carrier-map.webp)
-| Carrier | Continues | Breaks at |
-| --- | --- | --- |
-| Instruction files | Stable rules, architecture | Live WIP, weekly decisions |
-| Git / PR | Code changes, written review | Unwritten decisions |
-| Session resume / auto memory | Same tool, same project store | Other runtimes |
-| Nested agents / in-product multi-agent | Inside one ecosystem | Cross-runtime ownership |
-| Handoff markdown | Portable WIP story | Neglect, no template |
-| Coordination layer | Roles, threads, task status across agents | (next section) |
+[Open the full-size carrier map](/blog/keep-context-across-coding-agent-sessions/carrier-map.webp).
+
+- **Instruction files:** retain stable rules and architecture. They do not track live work or weekly decisions.
+- **Git / PR:** retain code changes and written review. Unwritten decisions are missing.
+- **Session resume / auto memory:** retain one tool's history or notes. Other runtimes and machines do not load private stores automatically.
+- **Nested agents / in-product multi-agent:** coordinate inside one ecosystem. Cross-runtime ownership still needs a bridge.
+- **Handoff markdown:** carries a portable work summary. It fails when the note is stale or nobody maintains it.
+- **Coordination layer:** connects roles, threads, and task status across agents. The next section explains its scope.
+
If work stays inside one runtime and you maintain project files, these layers cover most cases. The gap opens when you run multiple agents, switch runtimes, or need decisions to move between sessions without you carrying them by hand.
@@ -143,9 +215,9 @@ If work stays inside one runtime and you maintain project files, these layers co
The layers above still leave you as the sync point: read one session's output, paste into the next, or maintain a handoff no agent refreshes on its own.
-When that bridging is daily, the missing piece is not "more memory files." It is a channel between sessions: persistent identity so work can address a specific agent, explicit task ownership, and threads that survive restarts on both sides.
+When that bridging is daily, the missing piece is not only “more memory files.” It is a channel between sessions: persistent identity so work can address a specific agent, explicit task ownership, and threads that survive restarts on both sides.
-We built [Alook](https://alook.ai) as that coordination layer for local coding agents. Agents keep their own runtimes and in-tool memory. Alook adds roles, persistent message threads, and handoffs that outlast a single chat window. See [supported agents](/blog/ai-agent-team#supported-agents) for the current runtime list, and [how to build an AI agent team](/blog/ai-agent-team) for roles and handoffs.
+We built [Alook](https://alook.ai) as that coordination layer for local coding agents. Agents keep their own runtimes and in-tool memory. Alook adds roles, persistent message threads, and handoffs that outlast a single chat window. It does not merge every bot's private runtime memory. See [supported agents](/blog/ai-agent-team#supported-agents) for the current runtime list, and [how to build an AI agent team](/blog/ai-agent-team) for roles and handoffs.
Context can persist in files, in Git, in runtime memory, in handoff notes. Each carries something. None carries everything. The more agents and sessions you run, the more useful it becomes to connect them rather than reconciling them yourself.
@@ -153,14 +225,24 @@ Related: [When AI Agents Don't Share Context or Memory](/blog/shared-context-bet
## FAQ
+**What is agent memory for coding agents?**
+**Agent memory** is how a coding agent keeps, organizes, and later retrieves information from earlier work. Retrieved pieces can become context for a new call; saving something does not mean it is already loaded.
+
**Do CLAUDE.md or AGENTS.md restore my last chat?**
No. They load instructions into a new session. They are not a transcript replay.
**Is session resume enough when I switch from Claude Code to Cursor?**
-No. Resume and auto memory stay with the product that stored them.
+Usually not by itself. Resume and product auto memory stay with the tool that stored them. Shared files or an integration can bridge work, but private stores do not sync automatically.
**What belongs in a handoff file?**
-Goal, done, changed paths, verified checks, not-done or blocked items, next step, and do-not-touch notes — rewritten each handoff.
+Goal, done, changed paths, verified checks, not-done or blocked items, next step, and do-not-touch notes. Rewrite the file at each handoff, then re-check it for stale facts before the next edit.
+
+**How to give AI agent memory for past interactions**
+Save a compact record (product memory note or repo handoff), retrieve it in the next session, select only what the current task needs into context, then verify it against the current branch. That is not a full chat replay.
+
+**How do I add memory to my AI agent?**
+**How do I give an AI agent persistent memory?**
+Pick the tool's native memory when you stay in one runtime, or a repo handoff when you may switch tools. Write the note, confirm where it lives, load or `@`-mention it next time, and update or delete it when the decision changes. Persistent storage still needs an explicit read.
**When do you need more than files and git?**
When work crosses runtimes or spans days and you need owned next steps plus a thread you can reopen without reconstructing the chat.
diff --git a/src/web/blog/src/lib/blog/image-assets.json b/src/web/blog/src/lib/blog/image-assets.json
index b4ab08d29..5aa6431c8 100644
--- a/src/web/blog/src/lib/blog/image-assets.json
+++ b/src/web/blog/src/lib/blog/image-assets.json
@@ -32,20 +32,22 @@
"/blog/claude-code-and-codex-same-team/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/d533b2f3c720a020-480.webp 480w, /blog/_generated/d533b2f3c720a020-960.webp 960w, /blog/claude-code-and-codex-same-team/hero.webp 1200w"},
"/blog/claude-code-and-codex-same-team/machines-ui-20261015.png": {"width":1280,"height":720,"srcSet":"/blog/_generated/436fe30ed16a98d1-480.webp 480w, /blog/_generated/436fe30ed16a98d1-960.webp 960w, /blog/claude-code-and-codex-same-team/machines-ui-20261015.png 1280w"},
"/blog/claude-code-and-codex-same-team/review-loop-20261015.png": {"width":800,"height":1138,"srcSet":"/blog/_generated/2918fc3990127414-480.webp 480w, /blog/claude-code-and-codex-same-team/review-loop-20261015.png 800w"},
+ "/blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp": {"width":1000,"height":1400,"srcSet":"/blog/_generated/0ac21039c904f1a6-480.webp 480w, /blog/_generated/0ac21039c904f1a6-960.webp 960w, /blog/claude-code-dynamic-workflow-alternative/audit-to-handoff.webp 1000w"},
+ "/blog/claude-code-dynamic-workflow-alternative/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/367ac6d6ab928946-480.webp 480w, /blog/_generated/367ac6d6ab928946-960.webp 960w, /blog/claude-code-dynamic-workflow-alternative/hero.webp 1200w"},
"/blog/claude-code-subagents-vs-independent-agents/architecture-compare.webp": {"width":1400,"height":933,"srcSet":"/blog/_generated/5898f03690f372b0-480.webp 480w, /blog/_generated/5898f03690f372b0-960.webp 960w, /blog/claude-code-subagents-vs-independent-agents/architecture-compare.webp 1400w"},
"/blog/claude-code-subagents-vs-independent-agents/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/2a0837c3d61bfdca-480.webp 480w, /blog/_generated/2a0837c3d61bfdca-960.webp 960w, /blog/claude-code-subagents-vs-independent-agents/hero.webp 1200w"},
"/blog/claude-code-subagents-vs-independent-agents/three-layers.webp": {"width":1400,"height":933,"srcSet":"/blog/_generated/622dcce0a4478293-480.webp 480w, /blog/_generated/622dcce0a4478293-960.webp 960w, /blog/claude-code-subagents-vs-independent-agents/three-layers.webp 1400w"},
"/blog/how-to-delegate-tasks-to-ai-agents/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/98e567ac5790158d-480.webp 480w, /blog/_generated/98e567ac5790158d-960.webp 960w, /blog/how-to-delegate-tasks-to-ai-agents/hero.webp 1200w"},
- "/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png": {"width":800,"height":400,"srcSet":"/blog/_generated/a4db6813ec454187-480.webp 480w, /blog/humans-and-ai-agents-in-one-room/access-vs-attention.png 800w"},
- "/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png": {"width":800,"height":400,"srcSet":"/blog/_generated/ec65ca77fb3cd87e-480.webp 480w, /blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png 800w"},
+ "/blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp": {"width":800,"height":400,"srcSet":"/blog/_generated/aba2338d4f6c5e61-480.webp 480w, /blog/humans-and-ai-agents-in-one-room/access-vs-attention.webp 800w"},
+ "/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp": {"width":800,"height":400,"srcSet":"/blog/_generated/f7c991657d0976da-480.webp 480w, /blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.webp 800w"},
"/blog/humans-and-ai-agents-in-one-room/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/85c112903f9988f4-480.webp 480w, /blog/_generated/85c112903f9988f4-960.webp 960w, /blog/humans-and-ai-agents-in-one-room/hero.webp 1200w"},
"/blog/introducing-alook/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/49becde1c9acd55d-480.webp 480w, /blog/_generated/49becde1c9acd55d-960.webp 960w, /blog/introducing-alook/hero.webp 1200w"},
"/blog/introducing-alook/local-first-mobile.webp": {"width":1536,"height":1024,"srcSet":"/blog/_generated/aac695e53e357e95-480.webp 480w, /blog/_generated/aac695e53e357e95-960.webp 960w, /blog/introducing-alook/local-first-mobile.webp 1536w"},
"/blog/introducing-alook/local-first.png": {"width":1280,"height":720,"srcSet":"/blog/_generated/90988206c09344e9-480.webp 480w, /blog/_generated/90988206c09344e9-960.webp 960w, /blog/introducing-alook/local-first.png 1280w"},
"/blog/introducing-alook/one-identity.png": {"width":1280,"height":720,"srcSet":"/blog/_generated/a351d3127506fb08-480.webp 480w, /blog/_generated/a351d3127506fb08-960.webp 960w, /blog/introducing-alook/one-identity.png 1280w"},
"/blog/introducing-alook/overview.png": {"width":2364,"height":1594,"srcSet":"/blog/_generated/ca6cff5c8ff128f8-480.webp 480w, /blog/_generated/ca6cff5c8ff128f8-960.webp 960w, /blog/introducing-alook/overview.png 2364w"},
- "/blog/keep-context-across-coding-agent-sessions/carrier-map.webp": {"width":1643,"height":1155,"srcSet":"/blog/_generated/7800dade1d6c805d-480.webp 480w, /blog/_generated/7800dade1d6c805d-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/carrier-map.webp 1643w"},
- "/blog/keep-context-across-coding-agent-sessions/handoff-template.webp": {"width":1698,"height":1186,"srcSet":"/blog/_generated/4e5268fd68e01667-480.webp 480w, /blog/_generated/4e5268fd68e01667-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/handoff-template.webp 1698w"},
+ "/blog/keep-context-across-coding-agent-sessions/carrier-map.webp": {"width":1643,"height":1155,"srcSet":"/blog/_generated/92034d57bdc1bc6e-480.webp 480w, /blog/_generated/92034d57bdc1bc6e-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/carrier-map.webp 1643w"},
+ "/blog/keep-context-across-coding-agent-sessions/handoff-template.webp": {"width":1698,"height":1186,"srcSet":"/blog/_generated/7251fdb8de3c9c16-480.webp 480w, /blog/_generated/7251fdb8de3c9c16-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/handoff-template.webp 1698w"},
"/blog/keep-context-across-coding-agent-sessions/hero-og.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/20dd77821c7f5d15-480.webp 480w, /blog/_generated/20dd77821c7f5d15-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/hero-og.webp 1200w"},
"/blog/keep-context-across-coding-agent-sessions/hero.webp": {"width":1570,"height":1080,"srcSet":"/blog/_generated/12fb868c45fe8df0-480.webp 480w, /blog/_generated/12fb868c45fe8df0-960.webp 960w, /blog/keep-context-across-coding-agent-sessions/hero.webp 1570w"},
"/blog/local-ai-agents/hero.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/f901a75453510ab0-480.webp 480w, /blog/_generated/f901a75453510ab0-960.webp 960w, /blog/local-ai-agents/hero.webp 1200w"},