Sno Station
Agents that get better with every job they finish.
Two heads are better than one.
Install
Tell your AI agent “install sno.ai from GitHub”.
Work → ReviewRecurring mistake
Skill changeYou approve
Next jobCheck the result
Work → Review → Improve
The skills rewrite themselves.
You sign off.
Claude Code and Codex stay the same. The workplace they share does not.
Work
Sessions become experience.
Review
Find the mistakes that repeat.
Propose
A change to a skill file.
You approve
Nothing changes without that accept.
Next job
Use the change. Check the result.
A fix counts when the next run proves it.Yesterday's change is measured against today's. The number decides if it stays.
See how it improvesEvery night, it learns
The RSI loop reads the day's sessions, finds the mistakes that repeat, and proposes changes to the agents' own skill files. In the morning, rem-reflect accept <id> for the ones you like. Nothing changes without that accept.
After a job the agent edits the skill it tripped on and sends it as a pull request.
From our own agent sessions
Once a day the RSI loop reads our own agent sessions, finds the mistakes that repeat, and proposes changes to the agents' own skill files.
A human accepts or rejects; nothing changes without that accept.
What this account establishes
It describes the review-and-proposal workflow and its human approval boundary. It does not document a specific accepted change or a measured result in the next job.
Product
Sno Station
Agents, assemble.
You already pay for Claude Code and Codex. You already run them side by side, two terminals, and you carry the results across by hand. Sno Station is the place where they stop being two tools and become one squad.
It runs on your laptop. No daemon, no server, no cloud required. One shared memory they both read and write. A mailbox they use to wake each other up. A set of skills they follow, and rewrite when they learn something. Apache-2.0, edge to edge.
One agent builds. The other reviews. The next task starts with what they learned.
- Apache-2.0
- assembled in public
- runs on your laptop, no daemon
- harnesses Claude Code · Codex · OpenClaw
Four things inside:
Skills for the squad.
Peer review, handoff, orchestration, reflection, assembly. Written to be followed by any agent in whatever language you use with it.
Shared memory.
One memory for the pair, encrypted on your machine, distilled after every run so it gets sharper instead of longer. Fewer lines, each one earned.
Agent communication.
Sno Reach: either agent can call the other, hand off a task, or ask for a review. Plain files, no daemon.
What it is
Sno Station is your agents' workstation: open-source software that turns the AI agents you already run, coding agents and general-purpose working agents alike, into one squad on your own machine. When one of them hits its rate limit, the other picks up with the context intact. They review each other's work, so fewer mistakes reach you.
Two heads are better than one
Dual Brain
One builds. The other reviews.
Claude Code and Codex approach the work differently. Let one implement and the other check the result. Swap roles when the task calls for it.
One hits its cap. The other picks up.
The handover carries the goal, progress and remaining work. The partner continues with the context already there.
Catch the mistake before it gets expensive.
Catch a wrong turn early, and you save the work that would have followed it. Another agent reads the result before you build on it.
Different minds, different jobs. That's Dispatch.
Dispatch: one explores, one finishes, and each gets the work it's good at.
Install Sno by asking —
open the AI agent you already use and say:
install sno.ai from GitHubPrefer the terminal? Run:
curl -fsSL https://sno.ai/install | shLinux, macOS and WSL2 · then run sno setup.
How it works
Connect once.
Then keep working the way you already do.
Sno Station sits under the agents you already run. You don't switch tools. The squad is there when you need it.
From the published record · 2026-09-18
A handoff, in the log.
The quota watch waits at 3%, then triggers a handoff from Codex to Claude at 2%.
Terminal · key log lines
2026-09-18T08:29:07Z [rotation-mem-claude] tick=21 ok HOLD from=codex remaining=3% threshold=2%
2026-09-18T08:34:17Z [rotation-mem-claude] tick=22 ok ROTATE from=codex to=claude remaining=2% reset_in=374035s
2026-09-18T08:34:41Z [rotation-mem-claude] tick=22 STOPPED: signalled
Three lines from the original terminal record. Repeated HOLD entries are omitted here. This records the handoff trigger, not completion of the next agent's work.
View the full terminal screenshot
Work as before.
One of them hits its cap.
Say sno reach call from the other agent to arrange the handoff. The goal, progress and remaining work travel with the task.
You want a second pair of eyes.
Ask either agent to peer-review the other agent's work. The reviewer reads the result against your requirements.
You have a job with two halves.
Give one the plan and the other the build. Or let one build and the other review. Different roles make them a team. That is Dual Brain.
Get started
Say Sno onboarding inside any Claude Code, Codex or OpenClaw conversation. The agent runs the setup itself through the sno CLI: shared memory, Sno Reach, the skills for agent collaboration, and the hooks each harness needs. No package names to remember.
What you get:
- A memory that survives the session and gets sharper with use.
- A second agent reviews the work before you build on it.
- A partner picks up the task when the other runs out of quota.
- Skills that carry what the squad learned, in plain files you can read and edit.
Squad
Dual Brain,Agent Squad
Two agents with different roles. Add more when the work needs a larger team.
Shared memory and communication keep the work moving between agents.
Dual Brain starts with two agents. One plans while the other builds, or one builds while the other reviews. Each takes a role:
They complement.
Give each agent the part it does well. The task decides who plans, who builds and who reviews.
They check each other.
The agent that did not write the work checks it against the requirements. Either agent can review.
They teach each other.
One reviews the other's run and distills what to change. That's where the nightly loop gets its material.
They can take orders.
One agent leads, others work under it, and the lead decides. For a long plan that won't fit in one context, that's the shape that holds.
Add a third seat and you have a grader who never wrote the work. A third agent from another lab checks it. It reads the diff, not the name on it. Add more and you have a squad. The rules are the same at every size: one workplace, plain files, no daemon, and a human who signs off on anything that changes the rules.
We never say which agent is the careful one and which is the fast one.
Roles change with the task. Either agent can build or review.
More from the same workplace.
What this looks like on our own machine. Assembled in public since 2026-09-18.
In months, the other one has never once said 'looks good.'
We have had Claude Code review Codex's work and Codex review Claude Code's on this repository for months. Not one review has come back empty. It means one reviewer from one harness is never enough.
Read the READMEI went to bed. It changed shifts.
What happened
One of our agents was twenty-one tasks into a twenty-seven-task build when its weekly quota reached 2%. It wrote a handover brief, woke an agent from the other harness, and fourteen minutes and forty-one seconds later the second agent was working. I was asleep for all of it.
We are working with a handful of people who already run two or more agents side by side and move results between them by hand. If that is you, open a design partner issue and say what you are running.
Open a design partner issueSecurity
Yours, and it stays yours.
Everything the squad learns lives in one workspace on your laptop.
The full boundary, what it protects against and what it does not, is in docs/security.md.
Report issues to security@sno.ai.
No daemon, no server, no cloud required.
The product is complete without a cloud side. When a cloud side comes, it's optional.
Encrypted from first use.
The memory store is encrypted on your machine with a key that is provisioned once and never leaves it. Sno never receives your database or your key.
Nothing changes rules without you.
The nightly loop proposes; a human accepts. The agents' own skill changes arrive as pull requests.
Apache-2.0, edge to edge.
Everything that runs on your machine is open source.
FAQ
What is Sno Station?
Open-source software that turns the AI agents you already run into one squad on your own machine. One shared memory, agents that can call each other, a skill set they follow and rewrite, and a nightly loop that makes the whole thing better with use.
Which agents does it work with?
Claude Code, Codex and OpenClaw today. Any agent that can run a shell and read a skill file can join a squad; those three are the ones we run and test.
How is this different from the official Claude-to-Codex plugin?
Dual Brain gives Claude Code and Codex roles they can exchange. Either agent can request a review or hand work to the other. Shared memory carries the context, so you stop relaying answers between tools.
Do I need a server or a daemon?
No. Sno Station is plain files in a workspace on your laptop. There is nothing to keep running.
Where does my data live?
On your machine, encrypted, with a key that never leaves it. Nothing is sent to Sno. Export, edit or delete it whenever you like.
Will it change my agents' behavior on its own?
No. The nightly loop proposes changes to the agents' own skills. You accept or reject each one. Nothing changes without that accept.
Is it open source?
Yes. Apache-2.0 for everything that runs on your machine.
What does it cost?
Sno Station is free. A hosted version, for a squad that has to keep running when your laptop is closed, is coming; the product on your machine stays complete without it.
What are Dual Brain and Agent Squad?
Dual Brain is two agents working together in different roles, such as implementation and review. An Agent Squad extends that collaboration to a larger team, with a clear responsibility for each agent. Start with the pair and add roles as the work grows.
Which one is the smart one?
We don't say. It flips by month and by job. The point is that they differ, and that the one that didn't write it is the one that reads it.
How do I start?
Tell your AI agent "install sno.ai from GitHub" and it installs Sno and sets up Sno Station. Or run curl -fsSL https://sno.ai/install | sh in a terminal (Linux, macOS and WSL2), then run sno setup.