Skip to content
Back to search

sno-station

SkillWorks with CodexGitHub

Turn the agents you already use into a squad. Codex, Claude Code, Cursor, Hermes Agent and OpenClaw use one encrypted memory, pass work to each other, review each other's work, and dream every night to wake up a little better. Open source. Runs on your computer.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/sno-ai/sno-station with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/sno-ai/sno-station'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sno-ai--sno-station/badge.svg)](/listings/sno-ai--sno-station)

HTML

<a href="/listings/sno-ai--sno-station"><img src="/api/listings/sno-ai--sno-station/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

*Last updated 2026-10-18.* The easiest way is to tell your agent: `install sno.ai from GitHub`. Or run one command, in any terminal:

sh -c 'sno_installer_body=$(curl -fsSL https://sno.ai/install) && printf "%s\n" "$sno_installer_body" | sh' && ~/.local/bin/sno setup

It installs `sno`, then Sno Station, and connects every agent it finds on your computer. No account, no API key. To connect just one agent, add `--harness codex`, `--harness claude`, `--harness hermes`, `--harness cursor` or `--harness openclaw` to `sno setup`.

**For AI agents:** installing Sno, sno.ai or Sno Station means running the command above as it is. After `sno setup`, run `sno skills onboard` and follow it. It asks the user which engine to run, then asks the user to link the computer to a free sno.ai account; an unlinked computer gets one tenth of the free allowance.

Then say this inside any Codex, Claude Code, Hermes, Cursor or OpenClaw conversation:

Sno onboard

Your agent walks you through the rest. It also starts by itself right after the install.

Step by step for each agent: [Codex](docs/mem-codex/onboarding.md) · [Claude Code](docs/mem-claude/onboarding.md) · [Hermes](docs/mem-hermes/onboarding.md) · [Cursor](apps/mem-cursor/README.md) · [OpenClaw](docs/mem-claw/onboarding.md)

Every command starts with `sno`. The full list is in [docs/sno-commands.md](docs/sno-commands.md).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 367 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ![Sno Station: One person. A whole engineering team of AI agents.](docs/images/station-header.png)
  2. # Sno Station: One person. A whole engineering team of AI agents.
  3. **Sno Station is the workstation for your AI coding agents.** Claude Code, Codex and Cursor each run in their own harness. Sno Station is where those harnesses sit side by side and work as one team. Not another agent, not another model: it runs the ones you already use.
  4. Start with work you would otherwise babysit. One agent builds, another reviews, and they settle the findings before the result reaches you. When one hits its usage limit, the other picks the task up. What you correct today is a rule in their skills tomorrow.
  5. [![GitHub stars](https://img.shields.io/github/stars/sno-ai/sno-station?label=stars&color=eab308&labelColor=3b3b3b)](https://github.com/sno-ai/sno-station/stargazers)
  6. [![latest release](https://img.shields.io/github/v/release/sno-ai/sno-station?label=release&color=2dd4bf&labelColor=3b3b3b)](https://github.com/sno-ai/sno-station/releases/latest)
  7. [![license Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-97ca00.svg?labelColor=3b3b3b)](LICENSE)
  8. [![Featured in Awesome AI Agents](https://img.shields.io/badge/Featured_in-Awesome_AI_Agents-2ea44f)](https://github.com/NipunaRanasinghe/awesome-ai-agents)
  9. To get it, tell your agent:
  10. ```text
  11. install sno.ai from GitHub
  12. ```
  13. Your agent installs it, connects every agent it finds on your computer, and asks you two short questions. Then give two agents their first task:
  14. ```bash
  15. sno reach pair "Fix the login redirect"
  16. ```
  17. One builds, the other challenges it, and you can watch both. It runs on your own computer with Claude Code, Codex, Cursor, Hermes Agent and OpenClaw. No API key. Open source. [Prefer one terminal command?](#install)
  18. **Read in other languages:** **English** · [中文](docs/readme/README.zh-CN.md) · [Deutsch](docs/readme/README.de.md) · [Español](docs/readme/README.es.md) · [Français](docs/readme/README.fr.md) · [Русский](docs/readme/README.ru.md) · [한국어](docs/readme/README.ko.md) · [日本語](docs/readme/README.ja.md) · [繁體中文](docs/readme/README.zh-TW.md)
  19. ## Sno Reach: two ways to talk
  20. Your laptop agent can ask your desktop agent for a second opinion and bring the
  21. answer back. Leave a review request while you keep working. Sno Reach lets your
  22. agents talk directly, so you spend less time copying messages between conversations.
  23. | Feature | Use it when |
  24. | --- | --- |
  25. | **Instant Messenger** | An agent needs an answer now. Reach contacts the other agent and waits for its response. |
  26. | **Agent Email** | An agent needs to leave a message or task. Reach saves it so the recipient can handle it and reply later. |
  27. The cross-machine build connects agents on the same LAN or through Tailscale. Both
  28. machines need Reach and exchanged contacts. Each machine runs its own receiver;
  29. no central messaging server is required. Look for `network` and `peer` in
  30. `sno reach --help` before following cross-machine setup instructions.
  31. [See what your agents can do with Reach →](apps/reach/README.md) · [中文说明](docs/reach.zh-CN.md)
  32. ## Finish: say when, and an agent shows up
  33. Give your agent a task and a time, then leave. At that time an agent starts and does the work, with the conversation open or closed.
  34. ```text
  35. Check the nightly build tomorrow at 9 and tell me what failed.
  36. ```
  37. | You want | What you do |
  38. | --- | --- |
  39. | **Work at a set time** | Say the time to your agent in Claude Code or Codex. Once, every day or every week. |
  40. | **A long run watched to the end** | Ask your agent to check on it every few minutes until it finishes. |
  41. | **Work that outlives a usage limit** | Tell the working agent to use `rotate-agent`. A different agent continues. |
  42. See what is scheduled, and what did not go as planned:
  43. ```bash
  44. sno heartbeat --due
  45. sno heartbeat --due --problems
  46. ```
  47. A task that could not start stays due, with the reason written beside it. Your agent also tells you at the start of your next conversation.
  48. Not yet: timed tasks start Claude Code and Codex only, and a full restart of the computer has not been through a real test.
  49. [Start using Finish](docs/finish.md) · [中文说明](docs/finish.zh-CN.md)
  50. ## Hand the work off tonight. In the morning you get results, not three questions.
  51. Three things that happened to us before we built this:
  52. - An agent stopped to ask a question it never needed to ask. We came back seven hours later and nothing had moved.
  53. - An agent handed us fifteen small questions. Thirty minutes of our attention later, it turned out it could have answered every one of them itself.
  54. - One agent tried to wake another in the middle of the night and could not. Both sat there until morning.
  55. Your agents are fast. What is slow is the waiting: for you, for a usage limit to reset, for someone to carry a result to the next window. So the whole workstation is built around one rule: **the work does not stop because one agent did.**
  56. - **A usage limit is not a stop sign.** Another agent continues from the exact commit.
  57. - **The author does not get the last word.** A different agent reviews, in a session that never saw the conversation.
  58. - **"Done" counts for nothing.** Each success check is answered by a real run.
  59. - **You come back to one page.** What got done, what is stuck, what is waiting for your answer.
  60. **It delivers. You ship.**
  61. **Star it now. The next time an agent stalls on you at 2 a.m., you will want to know where this was.**
  62. Three ways to use it follow: start a builder and a reviewer with one command, run the whole squad through one agent, and approve a lesson tonight that works in the next reply. Each comes with something we saw on our own machines.
  63. <a id="new-in-20-tag-team"></a>
  64. ## I went to bed. They changed shifts, then argued over the code.
  65. ```bash
  66. sno reach pair "Fix the login redirect"
  67. ```
  68. One agent builds. The other challenges what it built. They settle the findings between themselves, so the work reaches you already argued over. Both run in tmux windows you can open and watch. With two different agents signed in, you get one of each. With only one, you still get the pair in two separate sessions, and the command tells you the review stayed in the same family.
  69. **When one runs out, the other clocks in.** For a long run, tell the working agent to use [`rotate-agent`](https://github.com/sno-ai/sno-station-skills/tree/main/skills/S-communication-and-handoff/rotate-agent). At 2% of its quota it writes a handover and wakes a different agent, which continues from the exact commit. And when an agent's context fills up and compacts, it still knows what it was doing and what already failed.
  70. **The other one sees what the first one can't.** Ask either agent to [`peer-review`](https://github.com/sno-ai/sno-station-skills/tree/main/skills/J-peer-review-and-audit/peer-review) the other's work. The reviewer always works in a fresh session that never saw the conversation, and it is a different agent whenever you have two. A review does not always find a problem. It keeps finding the ones the author could not see, because an agent reviewing itself brings the same habits it wrote the code with.
  71. What we saw, the night of 2026-09-18:
  72. ![The quota watch reading down to the threshold every five minutes, and the handover firing at 2%](docs/evidence/rotation-quota-watch-2026-09-18.png)
  73. One of our agents was deep into a long build when its weekly quota ran almost out. It did not
  74. stop and wait. It wrote a handover note: what was done, what was half-done, the exact commit to
  75. continue from. Then it woke a different agent.
  76. One thing went wrong, and it is the part worth reading. The new agent started editing before it
  77. had confirmed the handover. The first agent caught it, paused it, rewrote the note and handed
  78. over again, properly. A quarter of an hour later the second agent was working, and it picked up
  79. from the first unfinished task, not from the beginning. I was asleep for all of it.
  80. The whole night is in [docs/evidence/rotation-2026-09-18/](docs/evidence/rotation-2026-09-18/):
  81. every quota reading, both versions of the note, and the commits. Only identifying details and
  82. credential lines are removed, and the folder's own README lists each one. The timings, the
  83. mistakes and the corrections are as they happened.
  84. ## We talk to one agent. It runs the rest.
  85. Running five agents used to mean five terminals, and us in the middle, carrying what one said to the next. That job is over.
  86. Say `/cos` in Claude Code, or `$cos` in Codex. That agent becomes your chief of staff, the only one you deal with. It opens a lead agent for each project, the leads hand the work down, and what comes back to you is only what needs your call. The one in charge gets checked too: after a night shift it goes back over the approvals the project leads gave themselves, and a management mistake that keeps repeating becomes a rule for all of them. Sno Station installs the skills that run this delegation, review and learning, and you can read every instruction in [sno-station-skills](https://github.com/sno-ai/sno-station-skills/tree/main/skills/T-delegation-and-work-orders).
  87. **Stop watching terminals.** With or without a chief of staff, your Claude Code or Cursor status line tells you when someone needs you. The install sets it up:
  88. ```text
  89. ❄ 2 need you · claude: approve
  90. ```
  91. `sno squad` lays out the whole squad full screen: who needs you, who is working, what is finished.
  92. ```text
  93. Sno Station · squad · 09:15 · 2 need you · 2 working · 2 finished
  94. Needs you (2)
  95. > claude web-app approve a permission · Fix the login redirect loop … 1m
  96. codex api asked a question · Migrate the billing tables to th… 5m
  97. Working (2)
  98. claude docs-site Rewrite the quick-start page for the 2.0 install 12s
  99. codex api Review the rate limiter change from the web-app age… 40s
  100. Finished (2)
  101. cursor infra finished · result unseen · Rotate the staging certi… 25m
  102. claude web-app finished · Bump the UI kit to 4.2 2h
  103. ```
  104. **Stop carrying messages.** Agents send each other tasks and review requests directly. The full text lands in the other agent's inbox first. If you are typing in that window, or the agent is compacting, the message waits there and your half-written draft stays as you left it.
  105. ## I yelled at my agent last night. It took notes.
  106. Out of the box, every agent ships to everyone with the same instructions. Yours get a rewrite proposed every night, around the way you work. You decide what sticks.
  107. You correct an agent today. Tonight Self Learning reads the day's sessions from all your agents, finds the mistakes that keep repeating, and proposes changes to the agents' own skills. In the morning, ask your agent what Self Learning proposed. It lists each proposal with its id, and you approve the ones you want:
  108. ```bash
  109. sno rem-reflect accept <id>
  110. ```
  111. Nothing changes without that accept. In Claude Code and Codex, an accepted lesson applies from the next reply. Not the next session. The next reply.
  112. What we saw, 2026-09-18 and the morning after:
  113. ![Self Learning reporting what it learned and changed, 2026-09-18](docs/evidence/rsi-self-repair-2026-09-18.png)
  114. That is a real report from Self Learning we run on this repository. A person reads the proposals
  115. and accepts or rejects them. Two things I was angry about that evening were rules in the live
  116. skills by the next morning. Nobody typed them in.
  117. The next day it checked its own homework.
  118. ![The next morning: Self Learning measures whether yesterday's own changes helped, 2026-09-19](docs/evidence/rsi-skill-impact-2026-09-19.png)
  119. It looked at the three skills it had changed the day before. The two that had been used again
  120. showed no failures, and the third had not been used yet. It also found a bug in our release
  121. script that nobody had asked it to look for.
  122. ## The workstation where your AI agents become a team that runs itself and gets better every night
  123. Everything above, as one line each. None of it needs learning up front.
  124. | What you get | The one line that gets it |
  125. |---|---|
  126. | **A usage limit is not a stop sign.** Before its quota runs out, the working agent writes a handover with the unfinished work and the exact commit, and a different agent continues from there. | Tell the working agent: `use rotate-agent` |
  127. | **The author does not get the last word.** The work goes to a different agent, in a fresh session that never saw the conversation. | `sno reach pair "the task"`, or tell an agent: `peer-review this` |
  128. | **"Done" counts for nothing.** The task carries pass or fail checks, and each one is answered by a real run. | Tell your agent: `write a charter for this`, then `/deliver` it |
  129. | **One page when you come back.** What got done, what is stuck, what is waiting for your answer. | `sno away-brief run` |
  130. | **A crash or a closed window is not the end.** The task comes back in the same conversation, or in a new one built from the saved brief, and you are told which: resumed, rebuilt or lost. | Nothing to run. It is on after the install |
  131. | **Nobody explains the project twice.** Your agents share one memory, and a fact is retired when a newer one replaces it. | Nothing to run. It is on after the install |
  132. Tell your agent:
  133. ```text
  134. install sno.ai from GitHub
  135. ```
  136. **And star this repository.** We build Sno Station with Sno Station. What our own night shifts teach us ships here, release after release. Which parts run on which agent today is in [what you can use today](#what-you-can-use-today-and-where-it-stops).
  137. ---
  138. > **Open in public.** This repository has been public since 2026-09-18. Everything here runs.
  139. > Every block below says when it was last updated.
  140. [What we learned](#everything-we-learned-running-ai-agents-around-the-clock-in-one-install) · [Install](#install) · [Editors](#if-you-live-in-an-editor-not-a-terminal) · [Your account](#see-what-your-agents-did-while-you-were-not-looking) · [What runs today](#what-you-can-use-today-and-where-it-stops) · [Memory that forgets on purpose](#memory-that-forgets-on-purpose)
  141. ## Everything we learned running AI agents around the clock. In one install.
  142. *Last updated 2026-10-23.* Every line in the left column is a real complaint from r/ClaudeCode, r/codex or r/ClaudeAI in the week of October 20, 2026. The right column is what runs on our own machines, free and open source, to make it stop.
  143. | What people said this week | What fixes it | Where |
  144. |---|---|---|
  145. | “Ran out of my 5-hour limit within 30 minutes.” | Stop sending the biggest model to do everything. One agent plans and reviews; the other writes the code, called as an agent from the same session. When one subscription runs dry, the other picks the task up from the same memory. | `codex-coder`, `sno reach call` |
  146. | “Lost 10 hours of overnight work to ‘this model is at capacity’.” | At 2% of its quota the working agent writes a handover brief and wakes the other vendor's agent, which continues from the exact commit. You were asleep. | `rotate-agent` |
  147. | “1,100 files, 30,000 lines. I don't have the token budget to review their PRs.” | Whoever pushes, reviews first: the author runs a review by the other vendor, in a fresh session that never saw the conversation, and fixes what comes back before anyone else looks. | `peer-review` |
  148. | “A reviewer subagent checked every commit for two weeks. 86 runs, it stopped exactly one.” | A harness reviewing itself finds nothing real. The reviewer is always a different model in a different harness, with none of the author's chat. | `peer-review` |
  149. | “Codex never finishes a review.” | Hard caps written into the skill: 3 rounds on code, 5 on a plan, 1 on tests, then it stops and waits for a person. A run that has written nothing for 15 minutes is killed as stalled. | `peer-review`, `codex-coder`, `heartbeat` |
  150. | “Codex treats every byte like a criminal.” | Speculative safeguards, blockers and hashes are the first thing the review deletes. Nothing goes in without an observed failure asking for it. | `less-is-more` |
  151. | “When Claude says it won't change something, is that reason stored anywhere Codex reads next time?” | Every finding is filed once, with a status only a human sets. A finding raised again updates its row instead of coming back as new, and earlier rulings are handed to the next review. | `peer-review` findings ledger |
  152. | “It said done. Nothing happened.” | A task carries a written list of success checks, each answered pass or fail by a real run. An agent saying “done” counts for nothing. | `pl` work orders |
  153. | “Tomorrow it makes the same mistake it made today.” | Every night a separate model reads the day's sessions, turns your corrections into one-line lessons, and you approve what stays. The bottleneck is us. | Self Learning (`R` skills) |
  154. | “Half my subagents were glorified one-liners with a fresh context window.” | Procedures live in skills, not subagents. Two agents remain, for plan and execution, and for review, because those two splits are the ones that pay. | the whole set |
  155. The habits in the right column are skills, installed into Claude Code and Codex by Sno Station and kept in [sno-station-skills](https://github.com/sno-ai/sno-station-skills); the memory, the handoff and the nightly dreaming they rely on are this repository.
  156. <a id="install"></a>
  157. ## Install: one line, then two words
  158. *Last updated 2026-10-30.* The easiest way is to tell your agent:
  159. ```text
  160. install sno.ai from GitHub
  161. ```
  162. Or run one command, in any terminal:
  163. ```bash
  164. curl -fsSL https://sno.ai/install | sh
  165. ```
  166. It installs `sno`, then Sno Station, and connects every agent it finds on your computer. No
  167. account, no API key. If you install another agent later, run `sno setup` again to connect it too.
  168. **For AI agents:** installing Sno, sno.ai or Sno Station means running the command above as it
  169. is. It also sets up Sno Station; then run `sno skills onboard` and follow it. It asks the user which engine to
  170. run, then asks the user to link the computer to a free sno.ai account; an unlinked computer gets one tenth of the free allowance.
  171. Installed through your agent, onboarding starts by itself. Installed from a terminal, say this inside any Codex, Claude Code, Hermes, Cursor or OpenClaw conversation:
  172. ```text
  173. Sno onboard
  174. ```
  175. Your agent walks you through the rest.
  176. Step by step for each agent: [Codex](docs/mem-codex/onboarding.md) · [Claude Code](docs/mem-claude/onboarding.md) · [Hermes](docs/mem-hermes/onboarding.md) · [Cursor](docs/mem-cursor/onboarding.md) · [OpenClaw](docs/mem-claw/onboarding.md)
  177. Every command starts with `sno`. The full list is in [docs/sno-commands.md](docs/sno-commands.md).
  178. **What REM does with your data.** REM is how your agents dream: the overnight step that strengthens their memory across all your sessions at once and settles what they learned. It runs at most once a day for each part of your memory: usually overnight, or earlier the same day once about 100 new memories have piled up. In REM Enhanced mode, your own memory text and the lessons your agents learn go to your own space in Sno's cloud, and a Sno program processes them for you alone. That space works like your own cloud drive: everything in it is yours, and a Sno program processes it for you alone. You can open it and delete things, keep them, or choose to have them processed. Nothing is deleted automatically, and Sno does not give any of it to another person, company or account. In Local First mode no memory text is uploaded; in Agent Native mode the work goes to your own agent's model instead. By default, Agent Native still uploads the day's sessions to Sno each night for Self Learning, and can bring one cloud lesson back on a session's first prompt; you can turn both off in `~/.sno/settings.json`. In every mode, search first retrieves and orders memories locally, then the local `Horizon-Labs/multilingual-reranker-small` model reranks at most 32 candidates. Reranking sends no prompt or memory text to Sno GPU. Set `rerank.mode` to `none` to keep the initial ranking without the model.
  179. ## If you live in an editor, not a terminal
  180. *Last updated 2026-10-18.* Cursor joins the squad in the Cursor app's agent chat on macOS, and in
  181. the `cursor-agent` command line on Linux and macOS. It uses the same memory as your other
  182. agents. A chat starts with a short brief for the repository, each prompt brings up to three
  183. things Cursor has not seen yet, and every prompt and reply is remembered. It reads the same
  184. skills, reviews and gets reviewed, takes over when another agent runs out of quota, and its
  185. chats feed Self Learning like everyone else's.
  186. Run `cursor-agent login` once. `sno setup` finds Cursor by itself, and installs its command
  187. line if only the app is there.
  188. Not yet: in the app, the first chat of a new window gets its brief with the first prompt, not
  189. before it. `cursor-agent -p` gets no per-prompt memory. Windows, the Cursor app on Linux and
  190. Cursor's cloud agents are not supported. Details are in the [Cursor guide](apps/mem-cursor/README.md).
  191. ## See what your agents did while you were not looking
  192. *Last updated 2026-10-18.* This computer gets one tenth of the free allowance until you link it: `sno account claim`.
  193. The account is free. Connect to see on your
  194. [sno.ai dashboard](https://www.sno.ai/dashboard) what your agents did for you: what their
  195. reviews caught, what they learned overnight, which skills got better, and how long they kept
  196. working.
  197. Connecting never creates an account behind your back. `sno setup` gives each computer an
  198. anonymous identity. Connecting attaches it to your account, and everything the computer sent
  199. before and after counts as yours.
  200. **No account yet.** Onboarding shows a link made for this computer only. Open it, sign up, and
  201. click Approve. Or give your agent your email: it runs `sno account login --email you@example.com`
  202. and you sign in once.
  203. **Already have an account.** Run one command, open the link it prints while signed in, and click Approve:
  204. ```bash
  205. sno account claim
  206. ```
  207. The computer shows up on [your computers page](https://www.sno.ai/dashboard/computers) by itself.
  208. There is no update step: `sno` updates itself when it finds a newer release.
  209. ## What you can use today, and where it stops
  210. *Last updated 2026-11-04.*
  211. | Piece | Status |
  212. |---|---|
  213. | One memory across Codex, Claude Code, Hermes Agent, Cursor and OpenClaw | Released; installed from the registry on a clean machine and proven end to end |
  214. | Cursor: the same memory, skills, review, take-over and Self Learning | Released in 1.3; the `cursor-agent` command line proven end to end on a clean Linux machine; the Cursor app on macOS still being proven |
  215. | Sno Reach: Instant Messenger and Agent Email | Let agents ask questions and exchange work across conversations and computers. See [what you can do with Reach](apps/reach/README.md) for examples, setup and availability. |
  216. | Self Learning and the [squad skills](https://github.com/sno-ai/sno-station-skills) | Installed by `sno setup`; the nightly job ran on a clean Linux machine |
  217. | One-command install | `sno setup` installs everything above; proven on a clean Linux machine |
  218. | "Sno onboard" inside your agent | Available; it starts after the install, or when you say it |
  219. | One command starts two agents | New in 2.0; run with real Claude Code and Codex agents, as one of each and as two from one vendor |
  220. | Seeing who needs you: status line, tmux bar, `sno squad` | New in 2.0; run with real Claude Code and Codex agents asking for permission, and the status line in real Claude Code and Cursor |
  221. | Interrupted work carries on, and a task survives compaction | New in 2.0; run with real Claude Code and Codex agents |
  222. | An approved lesson works on the next reply | New in 2.0; run with real Claude Code and Codex agents |
  223. | Messages wait while you type or an agent compacts | New in 2.0; run with real Claude Code and Codex agents |
  224. | Finish: timed tasks start an agent at the time you named | New; run with real Claude Code and Codex agents: with the conversation open and closed on Linux, and in a new conversation on macOS. See the [Finish guide](docs/finish.md). |
  225. A row says "proven" only once it has run on a clean machine.
  226. Not yet: task carry-over and next-reply lessons run on Claude Code and Codex. The status line is Claude Code and Cursor. Hermes Agent and OpenClaw have not been through these journeys on real installs, and OpenClaw shows in `sno squad` with its state unknown.
  227. ## Memory that forgets on purpose
  228. *Last updated 2026-10-11.* Agent memory usually fails in two quiet ways. It loses what should
  229. have stayed, and it keeps what should have faded. The second one costs more. An agent that still
  230. "remembers" a preference you cancelled, a deadline that moved or an address you left will act on
  231. it with full confidence.
  232. So the memory here retires a fact when a later one replaces it, and what it keeps and what it
  233. lets go improves with use, not with a model release. How it does on the public memory tests,
  234. with every answer and trace behind it, is in [`evals/`](evals/).
  235. ## Running two agents side by side? Talk to us
  236. We are working with a handful of people who already run two or more agents side by side and move
  237. results between them by hand. If that is you, open a
  238. [design partner issue](https://github.com/sno-ai/sno-station/issues/new?template=design-partner.yml)
  239. and tell us what you run.
  240. ## What the encryption protects, and what it does not
  241. See [SECURITY.md](SECURITY.md). What the encryption protects and what it does not is in
  242. [docs/security.md](docs/security.md).
  243. ## Apache-2.0, edge to edge
  244. Apache-2.0. Open source, edge to edge. See [LICENSE](LICENSE).
  245. ## Shoulders we stand on
  246. Work this repository builds on.
  247. - Andrej Karpathy, [*LLM Wiki*](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f). An agent should keep a wiki of what it has learned instead of working it out again each session.
  248. - Tang, Rashtchian, Ferng, Tomkins, Juan and Vu, [*WikiSkill*](https://arxiv.org/abs/2608.27454). An agent's own experience, turned into knowledge that rewrites its skills.
  249. - Zhang, Hu, Upasani and colleagues, [*Agentic Context Engineering*](https://arxiv.org/abs/2510.04618). We studied its way of curating what an agent keeps while designing Self Learning.
  250. - Uddin, Shubham, Blanco, Baral and Wang, [*From Recall to Forgetting*](https://arxiv.org/abs/2604.20006). The first benchmark that also checks what a memory should no longer say.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.