Sno Station

Turns the coding agents you already run into one squad with shared encrypted memory, handovers and peer review.

Stars
★ 904
Last updated
3d ago
License
Apache-2.0
Primary language
TypeScript

At a glance

How it runs
CLIAgent plugin / skill
Works with
Portable with changesCodex · Claude Code
Cost
Free tier plus a paid hosted plan
Setup effort
Low · running in minutes
You'll need
macOS or Linux for sno reachcursor-agent (for Cursor CLI)Sno Station installer from https://sno.ai/installShell / CLINetwork accessLocal filesystem
Typical use
A developer running both Codex and Claude Code who hits a weekly quota mid-build and wants the other agent to continue from the same context instead of restarting.
Not a fit if
  • Teams that need the Cursor app on Windows or Cursor cloud agents
  • Teams that need memory text to never leave the machine at all
  • Teams that refuse any optional cloud account or hosted processing path

What does this agent do, and when should you use it?

Sno Station is an Apache-2.0 open-source tool that runs on your own computer and links Codex, Claude Code, Hermes Agent, Cursor and OpenClaw into a single squad. All of them read and write one encrypted memory, so when one agent hits its rate limit another can pick the task up from the same memory and mailbox with its context intact. Either agent can peer-review the other's work, and the reviewer is always a different agent. At night a REM step consolidates memory across every session, while Self Learning mines the day's sessions for repeated mistakes and proposes edits to the agents' own skills — nothing changes until you run sno rem-reflect accept. Memory, messages and skills stay on your machine with a key that never leaves it, there is no daemon, and sno setup wires in whichever agents it finds.

The installer drops the sno command and Sno Station onto the machine, and sno setup discovers each installed agent and connects it to the shared memory. Saying Sno onboard in any connected conversation walks you through the rest. Day to day, each prompt and reply is remembered; when memory is searched, candidates are ordered locally first and then at most 32 of them are reranked by the local Horizon-Labs/multilingual-reranker-small model (disable with rerank.mode set to none). When one agent runs out of quota, sno reach call from another agent resumes the task from the same memory and mailbox. To get a second opinion you ask either agent to peer-review the other's work. Overnight, REM merges and strengthens memory across sessions and retires facts superseded by later ones, while Self Learning reads the day's sessions, finds recurring failures and proposes skill changes that you accept with sno rem-reflect accept <id> the next morning. The processing mode — REM Enhanced, Local First or Agent Native — is set in ~/.sno/settings.json and determines whether memory text goes to Sno's cloud.

  1. A developer running both Codex and Claude Code who hits a weekly quota mid-build and wants the other agent to continue from the same context instead of restarting.
  2. A team that wants Claude Code reviewing Codex output and vice versa, so the reviewer never shares the first agent's habits of agreement.
  3. A Cursor user on macOS or Linux (in-app chat or the cursor-agent CLI) who wants Cursor's chats in the same repository memory and skills as the other agents.
  4. A solo developer with months of agent sessions who wants memory consolidated overnight and stale preferences, moved deadlines and old addresses quietly retired.
  5. A team that wants agents to learn from repeated mistakes but insists every skill change be reviewed and explicitly accepted by a human.
  6. A privacy-conscious user who wants memory and messages to stay on the laptop while still having the option of cloud-enhanced processing.

How do you install or deploy this agent?

The easiest path 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'

It installs sno and Sno Station and connects every agent it finds, with no account and no API key. If you install another agent later, run sno setup again. After installing, run:

sno skills onboard

For Cursor, log the command line in once first:

cursor-agent login

sno setup finds Cursor by itself and installs its command line if only the app is present.

How do you use this agent?

Keep working in whichever agent you already use. The three everyday moves are:

  1. When one agent hits its cap, say sno reach call from another agent; it picks the task up from the same memory and mailbox.
  2. When you want a second pair of eyes, ask either agent to peer-review the other's work.
  3. In the morning, review Self Learning's proposals and accept the ones you want:
sno rem-reflect accept <id>

Nothing changes without that accept. To link this computer to a free sno.ai account and get the full free allowance:

sno account claim

Open the printed link while signed in and click Approve. Processing modes and the rerank switch live in ~/.sno/settings.json; setting rerank.mode to none skips the rerank model. The full command list is in docs/sno-commands.md.

What are this agent's strengths and limitations?

Pros
  • One encrypted memory shared across Codex, Claude Code, Hermes Agent, Cursor and OpenClaw, so switching or handing over agents keeps the context and mailbox intact.
  • Quota handover is real and documented: sno reach call resumes a task, and the repository publishes the full night of a live rotation including both versions of the handover note and the commits.
  • The reviewer is always a different agent, breaking the pattern of a model approving its own habits; the author reports months of Codex/Claude Code cross-review with no empty reviews.
  • Memory forgets on purpose — later facts retire earlier ones — with public memory benchmarks, answers and traces under evals/.
  • Local-first with no daemon: memory, messages and skills sit on your computer under a key that never leaves it, and ~/.sno/settings.json can switch to Local First so no memory text is uploaded.
  • Self Learning never changes skills silently: proposals need sno rem-reflect accept, and the next night it measures whether its own changes reduced failures.
Limitations
  • Uneven support surface: sno reach is proven only on Linux and macOS, and the Cursor app on Windows, the Cursor app on Linux and Cursor cloud agents are unsupported.
  • Known Cursor gaps: a new in-app window gets its repository brief with the first prompt rather than before it, and cursor-agent -p receives no per-prompt memory.
  • Not purely local by default: Agent Native mode still uploads the day's sessions to Sno each night for Self Learning and can bring back one cloud lesson, both of which must be turned off in settings.
  • REM Enhanced mode sends your memory text and learned lessons to your space in Sno's cloud, which rules it out for organizations sensitive to data leaving the machine.
  • Local reranking depends on the Horizon-Labs/multilingual-reranker-small model, an extra runtime dependency.
  • The repository only went public on 2026-09-18 and some pieces (notably the Cursor app on macOS) are described as still being proven on clean machines.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Sno Station This agent 53 · Major gaps CLIFreemium ★ 904 3d ago TypeScript Codex · Claude Code
Maestro Orchestration Platform 75 · Some gaps Agent plugin / skillFree + model costs ★ 485 1d ago JavaScript Codex · Claude Code
MCO 73 · Some gaps CLIFree + model costs ★ 541 20d ago Python Codex · Claude Code
ECC Engineering Harness 66 · Some gaps Agent plugin / skillFreemium ★ 291k 1d ago JavaScript Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
53/ 100 5-point scale 2.7 / 5
Trust 16/29
Reliability 8/14
Adaptability 10/18
Convention 10/18
Effectiveness 6/13
Verifiability 3/8
Why each dimension lost points
Trust16 / 29 · 2.8/5

data_flow_transparency scores 3: security.md enumerates local SQLCipher encryption, key in settings.json at 0600, REM Enhanced and Agent Native default nightly session uploads, opt-out switches, and telemetry excluding memory content. least_privilege scores only 1: install is a curl|sh remote script and setup rewrites hooks, config.toml and permissions.allow across multiple agents with no minimization rationale. user_confirmation scores 2: Self Learning proposals require explicit accept and /memory clear requires --yes, but Agent Native's default nightly upload is on by default and must be disabled in settings.json, a weak confirmation posture. sensitive_data_handling scores 2: encryption and threat model are well documented, but key and store co-reside with no escrow, and REM Enhanced uploads plaintext memory text; boundaries are disclosed but real. dependency_security scores 1: many dependencies with caret ranges, no lockfile audit, SBOM or vulnerability scanning evidence; CI only builds. external_effects scores 1: install mutates several agent configs and registers hooks, a real side effect on the host with thin rollback guidance. rollback scores 1: docs stress reinstall preserves the store and to back up settings.json, but no version rollback or config-revert procedure. source_attribution scores 2: README credits Karpathy, WikiSkill and others, but code-level third-party attribution and NOTICE are not shown.

Reliability8 / 14 · 2.9/5

self_consistency scores 2: the three usage guides agree on mode tables, defaults and hook timeouts, and README matches security.md on REM; however README's 'no daemon' and 'runs on your laptop' sit in tension with an on-demand memory service and nightly uploads. dependency_availability scores 1: depends on Hugging Face model downloads (with mirror and SHA-256 pinning), npm packages, the Sno cloud and account allowance, limiting offline use. failure_messages scores 2: troubleshooting covers doctor states, no-repository-root, correction-in-progress and worker.log with concrete steps.

Adaptability10 / 18 · 2.8/5

audience_and_scenarios scores 2: clearly targets developers running multiple agents, with quota handover, peer review and nightly learning scenarios. capability_boundaries scores 2: the Cursor section and supported-surfaces list name unsupported cases (Windows, Cursor cloud agents, VS Code extension). trigger_precision scores 2: hooks specify timeouts, character caps, short-prompt skipping and subagent exclusion. environment_fit scores 1: requires a narrow Node version range, a git repository, and is Linux/macOS-centric with macOS and Desktop marked untested.

Convention10 / 18 · 2.8/5

information_architecture scores 2: README is well sectioned and docs are organized per harness, though numerous and densely cross-referenced. install_notes scores 2: commands, requirements, SNO_PROFILE_DIR and per-harness steps are present, but the core path is still a single curl|sh line without checksum or signature guidance. naming_stability scores 1: package names @snoai/mem-claude, mem-codex, mem-claw, mem-cursor coexist with sno/sno-mem commands, and the OpenClaw plugin name sno-mem-claw differs from its package name. examples_and_faq scores 2: example commands, an FAQ and described real-world evidence screenshots are provided. known_limitations scores 2: the 'what we do not protect against' list and Cursor's 'Not yet' section are candid. license scores 3: full Apache-2.0 text present and consistent with package.json. versioning_changelog scores 1: only 'Last updated' dates and a release badge; no CHANGELOG file. maintenance_responsibility scores 1: publisher identity is unverified and SECURITY.md only supports the main branch, leaving the responsible party unclear.

Effectiveness6 / 13 · 2.3/5

output_usability scores 2: commands and hooks produce concrete outputs (ids, supersede chains, JSON Lines export) usable directly. marginal_value scores 1: the core value (shared memory, peer review, nightly learning) depends on the Sno cloud and account allowance and overlaps with each agent's built-in memory, with independent gain not evidenced. cost_benefit scores 1: requires a resident service, rewrites of multiple agent configs and default nightly uploads, a non-trivial operational and privacy cost against largely vendor-asserted benefits.

Verifiability3 / 8 · 1.9/5

claim_traceability scores 1: README claims 'proven end to end on a clean machine' but the repository shows only screenshots and evidence-directory references, not reproducible test scripts or logs. cross_source_corroboration scores 1: README, security.md and usage guides corroborate the data flows, but all are the same publisher's documents with no independent corroboration. fact_inference_separation scores 1: docs blend design intent with observed results (e.g. 'never once said looks good') without clearly separating fact from inference.

Risks and how to mitigate them
  • Install runs a remote curl|sh script and rewrites hooks, config.toml and permissions.allow across multiple agents; review the script and back up configs first.
  • Agent Native uploads sessions to Sno nightly by default and must be disabled in ~/.sno/settings.json; REM Enhanced uploads plaintext memory text.
  • The encryption key and database live on the same machine with no escrow; losing settings.json makes the store unrecoverable.
  • Publisher identity is unverified, and README claims such as 'proven end to end on a clean machine' lack reproducible in-repo evidence.
  • Many caret-range dependencies and external model downloads with no visible vulnerability audit or SBOM.
Evidence confidence: Low Reviewed Oct 27, 2026 Reviewed revision 5b614e046c2e
See the full review method →

FAQ

Do I have to pay for anything?
No. The software is open source under Apache-2.0 and installs without an account or API key. An unlinked computer gets one tenth of the free allowance; sno account claim attaches the machine to a free sno.ai account for the full allowance.
Does my memory data leave my computer?
It depends on the processing mode. Local First uploads no memory text; REM Enhanced sends memory text and learned lessons to your own space in Sno's cloud; Agent Native delegates the work to your agent's model but by default still uploads the day's sessions nightly for Self Learning, which you can turn off in ~/.sno/settings.json. Search ranking is computed locally first.
Is the rate-limit handover reliable?
The published 2026-09-18 evidence shows one real failure: the incoming agent started editing before confirming the handover, was paused by the original agent, and the note was rewritten before a clean second handover. The full record is public, so treat handovers as dependent on the quality of the handover note.
Can Self Learning change my agents' skills without asking?
No. It only produces proposals, and a change takes effect only when you run sno rem-reflect accept <id>. The following night it checks whether its own accepted changes actually reduced the failures.
Which agents and operating systems are supported?
Codex, Claude Code, Hermes Agent, Cursor and OpenClaw. sno reach is proven on Linux and macOS; Cursor is supported in the app chat on macOS and via the cursor-agent command line on Linux and macOS, with Windows unsupported.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents