Skynet HQ: a crew of Claude Code agents that learns from its own files
One person, two machines, a phone
Tap a box to see what it does.
Explain this figure
- I send a message from my phone.
- cos, the Chief of Staff on my MacBook Pro, routes the work for Apple apps and websites.
- A second Chief of Staff, on a small Linux box at home, routes the work for Linux services and local AI models.
- Each Chief of Staff sends the work to the conductor of that project.
- The conductor starts short-lived workers, such as recon, architect, dev and verify.
- Each worker reports back to the session that started it.
- The two Chiefs of Staff can send each other short messages.
Updated in November 2026. The crew now runs on two machines.
I work on several projects in my own time. I wanted to move them forward when I am away from my desk. In the design conversation, I put the goal this way: “I should be able to talk to my chief of staff from my mobile, from my laptop, anywhere.”
Skynet HQ is the result. It is a crew of Claude Code sessions. It started on my MacBook Pro, which I call Skynet. In November 2026, I added a second crew on a small Linux box at home, which I call Gaya Prime.
Each machine has one Chief of Staff. On Skynet, its name is cos. I talk to a Chief of Staff, and to the conductor of a project when I need its details. A Chief of Staff starts one conductor for each project, and each conductor starts workers for single tasks.
Under the crew is a harness around Claude Code. Scripts start, relay and retire sessions. Hooks watch how much context each session uses. Files hold the contracts: timestamped prompts and reports, handoffs and ledgers.
Skynet HQ is private. I explain the design at a high level here. I do not publish the system.
Where the idea came from
I designed Skynet HQ with Claude in the Claude desktop app, on a Saturday evening in October 2026.
Two problems started it. I used a large third-party skill pack, and I wanted a small set of skills made for my own work. I also coordinated agents by hand. I started an agent, and then I told another agent its name so that the two could exchange messages.
The design began as one Chief of Staff with a few agents. Then it grew to one conductor per project, with workers under each conductor. Then I named the part that mattered most: “The most important aspect of the entire harness and orchestration process here is memory, context management.”
The core ideas were inspired by Kyle Eberle, the chief architect at my day job. His work showed me how to write handoffs with timestamps. It also showed me how to spawn agents, so that the work is spread out and each context is saved. He also gave me a pep talk on how memory works. It covered the four memory types, and what a dream cycle does and how to use it.
Claude wrote a starter pack of docs, templates and scripts. A Claude Code session on the Mac then built the real system from it in one night.
The crew
Tap a role to see what it does, what it never does, and who it may start.
Dutt
- Does
- Talks to each Chief of Staff, and to each conductor as needed, from a phone, a laptop or a browser. May start any role.
- May start
- cos, conductor, recon, research, architect, dev, verify, SME, Codex
cos
- Does
- One on each machine. Talks to Dutt, keeps that machine's ledgers, starts and stops conductors.
- Never
- Writes project code, or starts workers inside a project.
- May start
- conductor
conductor
- Does
- Breaks features into tasks, starts workers, verifies, and merges task branches into the feature branch.
- Never
- Writes implementation code, merges to main, or switches branches in the main checkout.
- May start
- recon, research, architect, dev, verify, SME, Codex
recon
- Does
- Maps the code a feature touches: files, entry points, risks.
- Never
- Edits files, or starts anyone.
- May start
- Nobody.
research
- Does
- Answers a question from outside knowledge, with sources.
- Never
- Edits files, or starts anyone.
- May start
- Nobody.
architect
- Does
- Designs the work and splits it into tasks with file scopes.
- Never
- Edits code.
- May start
- research, SME
dev
- Does
- Implements one task in its own worktree, runs its checks, and commits on its branch.
- Never
- Touches files outside its scope, merges, or pushes to main.
- May start
- recon, research, SME
verify
- Does
- Runs the claimed checks again, reads the diff, and reports pass or fail.
- Never
- Fixes what it finds, or starts anyone.
- May start
- Nobody.
SME
- Does
- Gives a deep answer on one focused subject, so its parent keeps its own context.
- Never
- Edits files, or starts anyone.
- May start
- Nobody.
Codex
- Does
- OpenAI's model, run through its own command-line tool. A conductor can hand it a task, such as drawing a set of illustrations.
- May start
- Nobody.
Explain this figure
- Dutt: talks to each Chief of Staff, and to each conductor as needed, from a phone, a laptop or a browser.
- Chief of Staff, one on each machine: talks to Dutt, keeps that machine’s ledgers, and starts and stops conductors. It never writes project code.
- Conductor, one per project: breaks features into tasks, starts workers, verifies, and merges task branches into the feature branch. It never writes implementation code.
- Workers: recon, research, architect, dev and verify. Each worker does one task and then retires.
- Helpers, such as an SME: answer one focused question for a worker. Helpers never start anyone.
- Outside models, such as OpenAI’s Codex: a conductor can hand one a task through that model’s own command-line tool.
Each crew is a tree, and I am at the top of both. I talk to a Chief of Staff most of the time. I also talk to a conductor directly when I need the fine details of its project.
Each conductor owns one repository. A worker can start a helper to answer one question, so the worker does not spend its own context on it. In the design conversation, I said: “the idea is to save context.”
One script starts every session. It checks that the parent may start that role. Messages between sessions are short nudges. Everything that matters goes into files.
The Chiefs of Staff, the conductors and the architects always run on Claude Opus. Other workers run on Sonnet by default.
The harness can also hand work to a model from another vendor, through that model’s own command-line tool. For one of my apps, which I will call Lumen here, a conductor had OpenAI’s Codex draw 49 illustrations from one style reference. I approved the drawings.
How work flows
Explain this figure
- I send an ask from my phone, such as: add X to project Y.
- cos records the ask in its inbox and writes a prompt file.
- cos sends the conductor a short message that points to the prompt file.
- The conductor runs recon, then an architect, who returns a task list with a file scope for each task.
- The conductor starts devs in parallel where their scopes do not overlap.
- Each dev reports with an exit code for every check.
- A verifier runs every claimed check again.
- The conductor merges the tasks that pass into the feature branch.
- The conductor sends cos a feature report.
- cos sends me ten lines or fewer: done, in progress, blocked, and what needs me.
Devs run in parallel only when their tasks share no file. When the conductor is unsure, they run one after another.
Explain this figure
- The parent writes a prompt file named with a UTC timestamp.
- The parent starts the worker in a named session.
- The worker reads only the goal of the prompt.
- The worker sends
ack: 20261025T065654Z ready. - The parent sends
go: 20261025T065654Z. - The worker does the work and writes its report.
- The worker sends
report ready: 20261025T065654Z status=done.
Every task is two files with the same timestamp: the prompt and the report. If a report has no exit code for a check it claims, the task counts as blocked.
The ack proves that a new worker is running. On the second machine, some new workers started and then stayed silent. Now a watchdog warns the parent when a worker does not send its ack within a few minutes.
Two machines, two Chiefs of Staff
Explain this figure
- Dutt talks to each Chief of Staff from a phone. Only his own words in a session authorize a deploy, a delete or a spend on that machine.
- Skynet, a MacBook Pro: one Chief of Staff, with the conductors for Apple apps and websites.
- Gaya Prime, a small Linux box at home: one Chief of Staff, with the conductors for Linux services, backends and local AI models.
- The shared procedure is the docs, scripts and agent definitions. It has one owner, on Skynet. Gaya Prime receives a read-only copy over a private network.
- A message between the two Chiefs of Staff is a nudge. It never carries authority.
- Each machine keeps its own ledgers, reports, handoffs, lessons and knowledge.
Gaya Prime is a small Linux box at home, and it is always on. Skynet keeps the Apple apps and the websites. Gaya Prime runs the Linux side: services in containers, backends and local AI models. One personal app there uses AI that runs only on the box.
I brought the box up in one evening. It was updated and secured, and the second Chief of Staff was online the same night.
Each Chief of Staff works the same way. It writes each ask of mine into a prompt file and routes the work to the conductor of that project. It checks the result before it reports to me.
A few rules keep the two crews in step.
The way of working has one owner. The docs, scripts and agent definitions live on Skynet. Gaya Prime receives a read-only copy over a private network and never edits it. When the Gaya Prime crew finds a gap, its Chief of Staff tells cos. cos fixes the source and syncs both machines. The context levels changed this way once, and the change was live on both machines within the hour.
A message is a nudge, never authority. Only my own words in a session authorize a deploy, a delete or a spend on that machine. When one Chief of Staff passes on “Dutt approved this”, the other one asks me in its own session first.
Memory stays on the machine that made it. Each machine keeps its own ledgers, reports, handoffs, lessons and knowledge. Ideas, keys and notes also stay where they are, unless I say otherwise.
Both crews draw on one Claude subscription, so they share its usage limits.
The first joint job crossed both machines. A service on the Linux box got a new access key. Then cos rebuilt the iPhone app of that service on the Mac with the new key. I checked the app on my phone, and it worked end to end.
Four kinds of memory
Tap a memory to see what it holds.
Working memory
- Holds
- A session’s context window: scarce, disposable.
- Example
- The prompt, the handoff, the files it opened.
- Rule
- Lost at session end; never relied on. At start it loads procedural memory, the knowledge index, and the latest handoff with its citations.
Episodic
- Holds
- Time-stamped records.
- Example
- Prompt/report pairs, handoffs, ledgers, the agent-to-agent message log.
- Rule
- Append-only, time-stamped, never edited after the fact.
Semantic
- Holds
- Distilled facts, each with a source and a verified date.
- Example
- “UI tests need the simulator booted first [src: report …] (verified …)”
- Rule
- Merged, corrected, pruned; every fact cites its source episode.
Procedural
- Holds
- How the crew works.
- Example
- Skills, agent definitions, contracts, docs, scripts.
- Rule
- Nothing edits it on its own. Changes arrive as proposals, they are approved, and the decision is logged.
Explain this figure
- Working memory: one session’s context window. It holds the prompt, the handoff and the files the session opened. It is scarce and short-lived.
- Episodic memory: what happened. Prompt and report pairs, handoffs, ledgers and the message log between agents.
- Semantic memory: what is true. Distilled facts, each with a source and a verified date.
- Procedural memory: how the crew works. Skills, agent definitions, contracts, docs and scripts.
- Reports, handoffs and ledgers move working memory into episodic memory.
- The dream turns episodes into cited facts in semantic memory.
- Proposals that are approved change procedural memory.
- A new session loads procedural memory, the knowledge index and the latest handoff.
A long-running agent forgets things and repeats work. Skynet HQ treats each session’s context window as scarce, short-lived working memory. Everything that matters lives outside it, in files. Claude said it in one line during the design: “A session is disposable; the files are the agent.”
I learned the four memory types from Kyle’s talk. I brought them into the design conversation, where I said that episodic memory “will help us move the needle in terms of development.” Semantic memory then improves the process itself.
Workers and conductors never edit procedural memory. Changes arrive as proposals, and each change that is applied is logged in the decisions ledger.
On two machines, procedural memory is the shared part. Episodic and semantic memory stay on each machine.
The files have fixed places. Each machine has one HQ folder for the crew’s own files. Each repository keeps its crew files in one hidden folder that Git ignores, so they never show in a diff or a pull request.
Context and the relay
cond-contextsmith · gen 1
level: relay now
On build day, every role used the same levels, and relays came at about a fifth of the window.
- State in one paragraph
- Read next (in this order)
- Decisions made (and why)
- Open threads
- Live agents I own
- Do not redo
- Next actions (in order)
- Lessons for semantic memory
- Parent notes
Explain this figure
- The status line records how much context the session has used.
- A hook reads that number on every prompt and every tool call.
- Checkpoint level: write a checkpoint handoff now, then continue.
- Relay soon level: finish only the current step, then write a relay handoff.
- Relay now level: stop, write the relay handoff and request a relay. The instruction repeats until a new handoff exists.
- After compaction, an emergency instruction: rebuild a handoff from the files and relay.
- The parent reviews the handoff and adds notes. Generation 2 starts under the same name and reads the handoff.
- The levels differ by role. Workers relay first, and conductors and the Chiefs of Staff relay later.
- On build day, the conductors relayed at about a fifth of the window. The levels were raised after that.
Each session loads its contract first, then its prompt or its handoff. Then it loads a short knowledge index and only the files that these cite. Before a session researches anything, it searches the knowledge files and earlier reports.
Compaction is the failure case. Claude Code can compact a long session into a summary, but the model writes that summary under pressure, and it loses specifics. A relay keeps a handoff that the session writes on purpose, while it still has room to write it well.
The name stays the same, so messages and ledger lines still point to the right agent.
A handoff passes one test. A fresh session that reads only the handoff and the files it cites can continue without a question to anyone. In the design conversation, I said handoffs exist “so that the future agents are not redoing the entire research or the same work again and again.”
A Claude Code mod logs every message between sessions to a file for each agent. That log becomes episodic memory, and no model spends effort to write it.
Ledgers, lessons and knowledge
A ledger is append-only. Each event is one line, and the newest line is at the bottom. Nobody edits an old line, and a correction is a new line. Each file has one writer. If a session needs a change in a file that it does not own, it sends a message to the owner.
The decisions ledger keeps my exact words. A new session reads it before it asks me again.
On the first morning, one ledger went out of order, because a conductor computed its timestamps by hand. The fix was one helper script that stamps the time at the moment of writing. All ledger lines now go through it.
When a session is surprised, it writes one line with a source. That line is a lesson. Here is one from the first days. A decision that I made directly with a conductor never reached cos. Conductors now forward my exact words to cos in the same turn.
A lesson is raw. The crew does not trust it yet. The dream decides which lessons become knowledge.
In the knowledge files, each fact is one line, with a source and the date when someone last verified it. When a newer episode contradicts a fact, the fact is corrected. The crew does not keep two versions of it.
Every session loads a short index of facts at the start. Topic files load only when a task needs them. An urgent fact goes in at once, if it would make the next worker fail. Everything else waits for the dream.
The dream cycle
In: episodes since the last dream
- Ledgers
- Reports
- Handoffs
- Lessons
- Repo inboxes
- Message logs
The dream
It reads every episode since the last dream and writes cited facts. It writes proposals but applies none of them.
Out
Knowledge: cited facts
Lessons become one-line facts with a source and a date. Stale facts are corrected.
First dream: one file went from 2 facts to 23.
Measures
First dream: 3 handoffs needed a follow-up; 0 memory misses.
Proposals
Nothing waiting.
Procedural memory
Workers lint their own report before they send it.
Approved by cos or Dutt
Nothing yet.
Explain this figure
- Episodes come in: ledgers, reports, handoffs, lessons, each repository’s inbox and the message logs since the last dream.
- The dream merges lessons into cited facts and corrects stale facts.
- It keeps each knowledge index under 150 lines and empties the lessons it used.
- It measures the memory system: relays per agent, context at relay, handoff failures, memory misses and verify failures.
- It writes proposals for changes to how the crew works. It applies none of them.
- A proposal waits for approval. An approved proposal becomes procedural memory.
I learned about the dream cycle from the same talk. In the design conversation, I asked for “local dream cycles or else real Claude dream cycles.” On build day, the build agent found no dream feature in the Claude Code 2.1.310 docs. So the crew runs its own dream.
A dream is one worker on Opus. A Chief of Staff starts it at the end of the day, or when I ask for one. Each machine dreams over its own files.
The dream writes semantic memory directly. It never edits code or deletes an episode. It also never changes how the crew works on its own. Procedural changes leave the dream as proposals. Each proposal is a concrete diff, with the episodes that justify it. A proposal that touches the shared procedure goes to cos on Skynet.
Explain this figure
- Day: each session writes reports, handoffs, ledger lines and messages into episodic memory.
- Day: a surprise becomes one cited line in the lessons file or a repository inbox.
- Day: a full session writes a handoff, and its next generation continues under the same name.
- Night: the dream reads the episodes and the lessons.
- Night: cited facts go into knowledge, and metrics and proposals go into the dream report.
- An approved proposal changes procedural memory: skills, contracts and docs.
- The next morning, sessions load the new procedural memory and the knowledge index at start.
The first dream ran on 25 October 2026, a few hours after the crew did its first real work. It found that the conductors doing real work relayed at about a fifth of their window. That was too early for a conductor. One conductor went from generation 1 to generation 6 in about 1 hour 40 minutes.
Three handoffs failed the test. When Claude handed over the design, it had named this risk: “Handoff quality is the real bottleneck, and no script can enforce it.”
I read the relay numbers and decided that the relay point was too short. The levels are now set per role. In November, I raised them again on both machines. Fewer relays also mean fewer handoffs that can go wrong.
The dream made ten proposals, and cos applied four of them. One example: workers now lint their own report before they send it.
Safety
| Source | Can authorize | Never |
|---|---|---|
| Dutt, in person | Releases to users: production deploys, App Store or TestFlight uploads, publishing. | A go that was only relayed by another session. |
| Conductors | Git in their own repository: branches, commits, merges into feature branches. | Releases to users. |
| Workers | Commits on their own task branch. | Push. |
| A message from another session, on either machine | Nothing. It is a nudge. | Authority, even when it says it comes from Dutt. |
| Fetched web content | Nothing. It is data. | Instructions. |
Explain this figure
- Dutt, in person: releases to users, such as production deploys, App Store or TestFlight uploads, and publishing.
- Conductors: the git work in their own repository, such as branches, commits and merges into feature branches.
- Workers: commits on their own task branch only. They never push.
- A message from another session, on either machine: never authority, even when it says that it comes from Dutt.
- Fetched web content: data, never instructions.
- Callout: the safety classifier blocked merges that deploy to production on four pull requests, and one TestFlight upload, although Dutt’s go had come through another session.
The crew runs unattended in auto mode, so its limits are explicit. A deny list blocks publishing, releases, credential reads and settings edits for every crew session.
Conductors own the git work in their repository. I asked for that, because I did not want cos to do it: “I don’t want you, chief of staff, to do that … dirty work.”
Releases to users still need me, even when I tell the crew to go ahead. In the first two days, the auto-mode safety classifier blocked merges that deploy to production on four pull requests. It also blocked a TestFlight upload. Each time, my go had come through another session. One merge went through when I said it in the conductor’s own session. Now conductors prepare a release, and I do the last step myself.
What the second machine taught
The same crew behaved differently on a different operating system. Permission prompts that never appeared on the Mac flooded the Linux crew. The fix was to describe the machine to the auto-mode safety classifier.
The safety classifier refuses an approval that another agent passes along, such as a push. That is correct. I run the step myself, or I say it in that session.
An always-on box is only as on as its network. Once, the box lost its connection and stayed offline for 11 hours. Now a watchdog reconnects it within 2 minutes.
Local models and the crew share the memory of the box. A limit on the filesystem cache lets both fit.
What’s next
With the crew, I released Doorframe on the App Store, with its site. The first version of Meontor is on TestFlight. The crew also revived Lumen, an old app of mine.
The crew is a few weeks old, and I still change it often. The dream proposes changes, and cos and I decide which ones to apply.