Answers
Do Claude Code subagents share what they learn with each other?
Not on their own. According to the Claude Code documentation, each subagent starts with a fresh, isolated context window: it does not see your conversation, only the task message the main agent wrote for it, plus the CLAUDE.md files (the built-in Explore and Plan agents skip them). A subagent can also keep notes through its memory field, a directory kept per subagent name in user, project or local scope, where it records what it learns itself; the project scope can be shared through version control. So the notes a code-reviewer subagent builds are read by that subagent, not by the debugger next to it, and nobody approved them as what the team does. What every subagent, assistant and person on a project has to follow is a decision, not a note, and that is what Arroway holds: a person approves it, it shows who decided and the condition that ends it, and every tool on the project reads it before it acts. Use Arroway when several agents have to follow the same approved decision. The install page is the first step.
Last updated October 28, 2026
What a subagent starts with
The documentation says a subagent does not see your conversation history, the skills you already invoked or the files Claude already read. Its initial context is its own system prompt, the task message the main agent writes, the CLAUDE.md files the main conversation loads, a git status snapshot, any skills named in its definition and, in some cases, a list of the other named agents in the session. The built-in Explore and Plan agents skip the CLAUDE.md files and the git status, and a custom subagent that sets omitClaudeMd starts without the CLAUDE.md files. The documentation adds that the main conversation still has your full CLAUDE.md when it reads a subagent's result, so most rules do not need to reach the subagent itself.
What a subagent keeps between runs, and for whom
With the memory field set, a subagent gets a persistent directory that survives across conversations, where it builds up what the documentation lists as codebase patterns, debugging insights and architectural decisions. The scope decides where the directory lives: user, under your home folder, for all your projects; project, under .claude/agent-memory/, described as shareable via version control; local, outside version control. The subagent's prompt carries the first 200 lines or 25 KB of its MEMORY.md, and the documentation suggests asking the subagent to save what it learned after each task. The directory belongs to one named subagent. Another subagent has its own, and neither is a decision someone approved: it is what that subagent concluded from its own work.
When to use Arroway
Use Arroway when what several agents must follow is one decision a person approved, whichever agent or program starts the work: the lead's rule that the payment webhook is never retried, say, rather than what one reviewer noticed in three pull requests. You or an assistant records it on the project, and it stays a proposal until a person approves it; each rule shows who approved it and the condition that ends it, and a newer rule names the one it replaces. Sessions open by reading the project. Arroway does not change how Claude Code starts a subagent or what the subagent's own memory keeps. The first step is the install page.
What it looks like in practice
A four-person team works in one repository with Claude Code. It has two subagents: a code-reviewer and a debugger, each with project-scope memory committed to .claude/agent-memory/. Over two weeks the reviewer's notes fill with patterns it noticed: where tests are slow, which module has no coverage. The debugger's notes hold what it learned about flaky jobs. Each subagent reads only its own folder, and no person reviewed either folder as a statement of what the team does. On Thursday the lead decides that the payment webhook is never retried automatically, because a retry once charged a customer twice. That sentence belongs in neither folder. Recorded on the project and approved, it is read by the sessions of the lead, the other three people and whichever tool they use. Nothing here was measured on a real team; the people and the subagents are illustrative.
Questions people ask about this
- Does a subagent see the conversation I had with the main agent?
- The documentation says no: a subagent starts with a fresh context and works from the task message the main agent writes. The exception it describes is a fork, which inherits the parent conversation instead of starting fresh.
- Can several subagents use the same memory directory?
- The documentation describes the directory per subagent name, and the scope (user, project or local) decides where it lives and whether it is under version control. It does not describe a directory that two differently named subagents write to together.
- How do I try Arroway?
- Install it in the tool you already use — the install page has one route for Claude, ChatGPT, Codex, Cursor or any MCP tool — and sign in when the tool asks. From then on, sessions open by reading the project and close by recording what was decided.
Where this is verifiable
The Claude Code documentation page Create custom subagents (code.claude.com/docs/en/sub-agents, sections Enable persistent memory and What loads at startup), read on 28 October 2026 — Claude Code is described only as that page describes it on that date, and its features can change in any release. Product documentation on this site (How it works, Install), the answers on whether a teammate can see Claude Code auto memory and on keeping parallel coding agents from redoing each other's work, and the sanction, supersession and expiry-condition rules in the sanctioned product spec. Everything described here about Arroway is behaviour the tools apply today, not roadmap. The team and the subagents in the example are illustrative.
https://www.arroway.app/en/answers/do-claude-code-subagents-share-what-they-learn