cosms
Less chaos.
More cosmos.
The operating system for
modern software teams

One system.
Every agent.
In sync.

Cosmos brings your people, agents and context together — context that compounds, one coding style for every AI, an architecture map that cannot go stale, and a gate for the review checklist. Committed to git; nothing to run.

first person on the repo · once
python3 -m pip install cosmos-dev
cosmos init
everyone after that
git clone <repo> && claude
Ledger
Context that compounds
Charter
One style for every AI
Atlas
Your living product map
Lanes
Focus and avoid overlap
Horizon
See a feature before it lands
Gate
The checklist, kept by the machine
Flares
QA that follows the code
Dreams
From activity to direction
Verdicts
The human gate
the problems · three months into a real project

Eight things every team building with AI says out loud.

Each one is a symptom of the same cause: knowledge, rules and structure live in individual sessions instead of in the repository.

“Everyone rescans the codebase.”
Ledger

What one person's AI learns is captured, checked and handed to the next person's session before they ask.

“Everyone tells the AI a different coding style.”
Charter

One working agreement, committed and changed in pull requests, injected into every AI session on every machine.

“People work across overlapping features.”
Lanes

Facts, findings and diagrams are filed by feature lane; two people active in one lane this month is shown before it becomes a merge conflict.

“Everyone has different strengths and thinking.”
Charter + Ledger

Strengths become team property: the person who knows Redis writes the constraint once; every AI inherits it. Thinking stays personal, decisions get a recorded reason.

“Product keeps dumping features; the app gets confusing.”
Horizon

A feature enters with its lanes, the decisions it collides with, the open findings in the way and the people already there — before code is written.

“No architecture diagram. If there is one, it is out of date.”
Atlas

Diagrams generated from the repository itself — manifests, compose, Kubernetes, Terraform, OpenAPI — and drift-checked every time those files change.

“Memory is one flat list, not organised by feature.”
Lanes

The ledger, the index and CLAUDE.md are grouped by lane, the way the team actually talks about the product.

“Every call: did you self-review, point precisely, run the tests?”
Gate

A hook holds the AI's turn until the tests for touched files ran, each change cites file:line, open findings on those files are addressed, and the diff is reviewed against the Charter.

for your role

What changes for each person on the team.

The same folder, read from five seats.

Product manager

“I keep adding features and the app gets more confusing. Nobody tells me what a feature collides with until it is half built.”
Horizon answers before a line is written: which lanes it touches, which recorded decisions it collides with, which open findings are in the way, who owns that area. The Atlas shows the real shape of the product, always current.

Project manager

“Three people ended up in the same feature. Every call repeats the same three asks. I cannot see who knows what.”
Lanes show who is active where and flag overlap this month. The Gate asks the three questions so the call does not have to. Dreams and Verdicts give a weekly rhythm: consolidate, decide, commit.

Developer

“I re-learn the codebase every session. My AI writes in a different style from my teammate's. I did not know that constraint existed.”
The Ledger hands over what others learned, matched to the files you touch. The Charter makes every AI write the same way. remember: keeps what you found in ten seconds.

QA

“My findings live in a document nobody reopens. Fixed bugs come back. Nobody tells me when a finding is picked up.”
Flares have a lifecycle and a board. A fixed bug reported again is flagged regressed. An open finding on a file the AI edits is raised at the Gate. Cards go to Slack once, with reactions to claim or close.

Tech lead

“There is no diagram, or it is a month old. Decisions live in people's heads.”
The Atlas is generated from the repo and drift-checked. Every decision in the Ledger carries its reason, evidence and date; contradictions surface instead of silently coexisting.
how it works

Five steps. The developer does only the first.

Green steps run by themselves. The gold one is where a person decides.

1
youWorkUse Claude Code as usual. The Charter, top facts and Atlas status are already in context.
2
automaticCaptureHooks mark the session range for the model, keep explicit remember: lines at once, and write one journal line per turn: the ask, the files, the commits. Transcripts are read in place, never copied.
3
reviewDreamRuns by itself when enough is waiting. The model reads the marked session ranges and your own Claude Code auto memory notes, keeps what the team should still know, files it by lane; duplicates merge, contradictions are flagged, the Atlas is drift-checked. A human settles what evidence cannot.
4
gitLedgerOne markdown note per fact, with evidence. Committed. Opens as an Obsidian vault.
5
automaticGate & recallBefore the agent edits a file it sees what the team knows about it. A turn that edits code is held once: tests, file:line, flares addressed, and the agent records what it learned while it still has the context. A commit naming a flare closes it.
Git is the database, in your branch.

.cosmos/ is ordinary committed files in the branch where you ran cosmos init: every branch made from it carries the team memory, and merging shares it. cosmos commits .cosmos/ every 10 minutes while you work and after each dream, in its own commit; it never pushes, the memory goes out with your branch. Append-only files merge by union. No server, no account, no cloud, nothing beyond your repository and the open-source cosmos.

what it does

Every feature, explained in plain English

What it is, what you do, what you get, and the command. Nothing here needs a server or an account.

Ledger

what the team knows
what
One markdown note per fact the team has learned — architecture, decisions and their reasons, conventions, constraints, bug root causes, dependency limits, workflows, domain rules — each with the files that prove it, the dates it was seen, how many times, and by whom.
you do
Nothing. Work in your AI tool; facts are captured when a turn ends. Type remember: … when something must be kept for sure.
you get
Your next session, and every teammate's, starts knowing what the last one learned. Ask cosmos why redis to see the evidence for anything.
command
cosmos capture · cosmos why · cosmos search · cosmos remember

Charter

one style for every AI
what
A short file, .cosmos/charter.md: how we write code, how we test, how we point at things, how we review our own work, our architecture rules. Owned by the team, changed in pull requests.
you do
Agree it once. Add a rule when a decision is made — from the UI, the CLI, or by typing remember: in a session.
you get
Every AI session on every machine reads it first. Personal preferences stop leaking into the codebase. Explicit rules outrank anything the AI inferred.
command
cosmos charter · cosmos charter add "…" · cosmos charter edit

Atlas

architecture that stays true
what
Inventory, container, deployment and API diagrams generated from what the repository already declares: package manifests, docker-compose, Kubernetes, Terraform, OpenAPI, .env.example, README. Every source file is fingerprinted.
you do
Run cosmos atlas once; type /atlas in Claude Code for the deeper pass (data flows, dependency index).
you get
A diagram that cannot quietly go stale: when compose or manifests change and the picture does not, everyone is told at the start of their session and on the Atlas page.
command
cosmos atlas · cosmos atlas --check · /atlas

Lanes

memory by feature
what
Every fact, finding and diagram is filed under the feature or module it belongs to, worked out from the files it points at (or configured by you).
you do
Optionally name your lanes in config.json, and fold near-duplicates with lane_aliases (cosmos lanes --propose suggests them). Otherwise nothing.
you get
A ledger organised the way the team talks about the product; per lane, who has been active in the last 30 days and where two people overlap — before it becomes a merge conflict.
command
cosmos lanes · cosmos review --repoint for facts whose files moved

Horizon

features arrive with a map
what
A one-sentence feature request turned into an impact note: lanes touched, recorded decisions it collides with, open findings in the way, people who have been working there, a suggested owner.
you do
cosmos horizon "bulk invite with partial success", or type it on the Horizon page.
you get
The conversation about a feature happens before the code, with facts. The note is saved next to the code the feature will change and travels with the pull request.
command
cosmos horizon "…" [-f file]

Gate

the review checklist, applied by the machine
what
A check that runs when the AI says it is done. If the turn changed code but ran no tests, gave no file:line references, ignored an open finding on a file it touched, or made a large change without a dead-code scan (vulture for Python, knip for JavaScript), the AI is handed the exact list and keeps going.
you do
Nothing. Tune the rules in the Charter if you want.
you get
“Did you test? Point precisely. Review your own change.” stops being something a person says on every call, and the agent records what it learned while it still has the context. Proportional: a small change is held only for its file:line and open flares. A turn is held at most once; documentation edits are never held.
command
cosmos gate · cosmos gate --transcript FILE

Flares

QA that follows the code
what
Audit findings as memory with a lifecycle: open → claimed → PR open → fixed, or needs a human, won't fix, withdrawn. A fixed bug reported again is flagged regressed. Each id carries the stage the project was in when it was found, read from git — DEV, QA (qa/* branches), UAT, RC (release/*), PROD (main after a version tag), HOTFIX — with nothing to run.
you do
Import the audit JSON (no file yet? cosmos offers to create an empty one), type flare: … in a session, or record bugs found by hand: + Record bugs on the Flares page, cosmos flares add "…", or a list (--from bugs.csv, .xlsx, .txt). Move cards on the board or with one command.
you get
Flares show up when someone touches the affected file. Slack cards post once, with reactions to claim or close. A report can be regenerated any time, and the whole list downloads as an Excel sheet.
command
cosmos flares add|import|list|fix|edit|stage|slack|report · cosmos flares export -o flares.xlsx · /flare, /flares, /qa in your agent

Dream & Verdicts

keeping it true
what
The model reads every new observation and decides what is worth keeping, rewrites it crisply, names its category and its feature lane. Then duplicates merge, contradictions are flagged, old facts are marked for review, the Atlas is drift-checked. Anything evidence cannot settle waits for a person on the Verdicts page.
you do
Run a dream now and then (or nightly in CI), glance at Verdicts, commit.
you get
A ledger that stays small and right. Every human decision — keep, both valid, still true, forget — is recorded with who and when.
command
cosmos dream · cosmos review · the Verdicts page

At a glance

Ledger

Architecture, decisions and their reasons, conventions, constraints, bug root causes, dependency limits, workflows, domain rules — each with its evidence files, dates and observers. cosmos why redis.

Charter

How we write, test, point and review, in one file. Injected first into every session. Add a rule from the UI, the CLI, or by typing remember: ….

Atlas

Inventory, containers, deployment and API diagrams from what the repo declares, on one navigable page (atlas.html: pan, zoom, full screen) as well as in Markdown. Hash-checked for drift. Dreams let the model follow the Atlas prompt and add system context, data flows and a dependency index.

Lanes

Every fact under the feature a product manager would name — assigned by the model, refined from paths. Who is active where, where people overlap, which lanes carry open findings.

Horizon

Map a feature before coding: lanes touched, colliding decisions, flares in the way, suggested owner. Saved beside the code it will change. cosmos horizon "…" or /horizon in your agent.

Gate

Tests run, file:line cited, findings addressed, self-review done — or the turn is not over. Held at most once, never loops, never gates docs.

Flares

QA findings with a lifecycle — open, claimed, PR open, fixed, needs a human, won't fix, withdrawn, regressed. Board, Slack cards, no double posting.

Dream

The model curates every new observation — keep or drop, rewrite, category, lane — then dedupe, contradictions, staleness, evidence-based supersession. Uses your Claude Code login by default; no key to paste.

Handoff

The last thing said on a branch is kept as its handoff, automatically; cosmos_handoff when stopping mid-work. The next session on that branch, on any machine, opens with it.

Team sources

Git history and pull-request review comments feed the ledger with nobody installing anything: every commit becomes a journal line; commit bodies and review remarks are offered to the model as candidate rules and facts.

Open Knowledge Format

The ledger is a conformant OKF v0.2 bundle — Google's open spec for knowledge as markdown with frontmatter — so the format is not invented here. Provenance, trust and freshness on every note; relationships as OKF links: each lane is a concept page linking its facts, flares, horizon notes, the services whose code it touches, and the people active there. Any OKF consumer or graph viewer traverses it. Retrieval is BM25 with an evidence-path boost; no vectors.

Recall, measured

Every dream that changed the memory measures two things on the repository's own facts and code: how often the fact about the code being edited is shown before the edit, and recall@5 for questions and file lookups (only files with five facts or fewer, where one fact can rank first). A fall of five points or more is named on the Dreams page and in cosmos doctor; numbers are only compared with runs measured the same way. On two real repositories, choosing pre-edit facts by the edit raised the first number from 39% to 81% and from 52% to 85%. cosmos eval runs both now.

Watch

cosmos watch: one local process that tails every agent's session files for this repo — all worktrees, subagents — captures what is new, shows who is working on what right now, and starts dreams. No hooks needed, so it also covers sessions opened before cosmos existed.

Recall at the edit

The moment the agent opens a file to change it, it sees the open flares on that file, its explicit rules, and the facts that match the code being changed: a file can carry a hundred facts, and the one about the function being edited is the one that matters. Each fact is shown once per session, so a later edit elsewhere in the file brings what is relevant there. Knowledge arrives at the decision, not in a report afterwards.

Journal

What the team did, not only what it learned: one line per agent turn — ask, files, commits, branch — filed by lane and person. Five commits and no new fact is still on record.

Control room

cosmos ui: overview, ledger, lanes, atlas, charter, horizon, flares, dreams, verdicts, activity, docs. Localhost only. Near-black and gold over a drifting night-storm sky behind glass panels, readable on a phone. The sidebar folds to icons; a fact or flare opens in a dialog; long lists page in the browser, so thousands of facts need no server.

Slash commands

/recall, /flare, /qa, /horizon and seven more, the same in Claude Code, Gemini CLI, Cursor, Copilot, Windsurf and Codex, written by cosmos connect.

Routines

cosmos's work as Claude Routines, in the cloud on a schedule or a GitHub trigger, with no laptop open: pr-review against the Charter and open flares, a daily pulse, a nightly dream, a weekly scan, merge-memory, flare-triage, digest. One line to set each up; the steps come with cosmos's upgrades. cosmos routines

Playbooks

A team's master QA protocol, runbook or SEO playbook becomes a command in every agent, found by itself (in Claude Code it also appears in the skill list; Codex gets it as a project skill in .agents/skills/; every agent finds it listed in AGENTS.md). cosmos playbooks add ../other/docs/qa/PROTOCOL.md shares one; cosmos playbooks add qa starts from a generic QA protocol.

Excel

cosmos export: flares, facts, rules, lanes, endpoints and playbooks, one sheet each; the ⬇ Excel button in the console does the same. Standard library only; text never runs as a formula.

Lane aliases

lane_aliases folds near-duplicate lanes (deploy-config → deploy) everywhere; cosmos lanes --propose suggests them. cosmos review --repoint follows moved evidence through git's renames.

Other agents

The same block is written to AGENTS.md, so Codex, Cursor, Gemini CLI and Copilot read the Charter and the facts too, and get the same slash commands.

Privacy first

API keys, tokens, passwords, private keys and credentials in URLs are redacted before anything is written. Sensitive folders can be excluded, and any word listed in ~/.config/cosmos/private_terms.txt (names, companies, anything) is redacted from every capture in every repository; the list lives in your home, so it is never committed.

Never in the way

Hooks finish in milliseconds and exit clean. The Gate is the one deliberate hold, and it explains itself.

every agent · one point of contact

Claude Code, Codex, Gemini, Cursor, Copilot, Cline, Cowork — one store.

Teams do not use one AI tool. cosmos meets each of them three ways, and everything lives in the repository, so sharing it is a git push.

They read the same rules

The Charter and the key facts are written to every tool's own instruction file, kept in sync automatically. In Claude Code you see each recall as one line: cosm◎s · recalled 3: …. cosmos updates itself: a newer release, checked against PyPI's checksum, is committed into the repository, and each version repairs what older ones wrote (cosmos upgrade --check, cosmos repair). The session briefing stays under Claude Code's 10,000-character hook limit, so the model reads all of it. A session opened in a folder above several repositories gets one line per repository, and Claude Desktop is warned when an MCP entry named cosmos serves another repository. A session in another project gets "not this project" from every cosmos tool and records nothing. The Gate also checks every turn for credentials, hidden Unicode and agent-steering text in instruction files, and for unaudited dependency changes; cosmos scan checks the whole repository.

  • CLAUDE.md — Claude Code, Cowork
  • AGENTS.md — Codex, Cursor, Copilot CLI, Gemini
  • GEMINI.md, .cursor/rules/, .github/copilot-instructions.md, .clinerules, .windsurfrules

They call the same tools

cosmos mcp is a Model Context Protocol server every one of these agents can connect to. cosmos init writes the configs.

  • cosmos_recall — facts and findings for the files you are about to touch
  • cosmos_remember, cosmos_flare — write back from any tool
  • cosmos_charter, cosmos_atlas, cosmos_lanes, cosmos_horizon, cosmos_why

They feed the same memory

Claude Code captures through hooks, in every worktree. cosmos watch follows Claude Code, Codex and Gemini session files on the machine whether hooks fired or not, and keeps a live picture of who is doing what. Web and cloud sessions are covered by the committed hooks and MCP tools. Cowork gets the tools from the cosmos plugin (this repository is its marketplace), with the next message; a session that was open before cosmos init is briefed on its next prompt.

  • hooks in the repo and for your user, written by cosmos init
  • the watcher starts with the first session and stops after two idle hours
  • git push: every teammate on every tool has it

Nothing to run after cosmos init. cosmos connect all, cosmos watch and cosmos hooks --user are there to repair a setup or to add a tool you install later.

They share the same slash commands

One catalogue, written by cosmos init / cosmos connect into every agent that reads project commands, so /qa means the same thing in Claude Code and in Cursor. Each command uses the cosmos tools and falls back to the committed wrapper.

  • /cosmos /recall /remember /flare /flares /qa /reconcile /lanes /horizon /handoff /atlas
  • Claude Code .claude/commands/ · Gemini CLI .gemini/commands/ · Cursor .cursor/commands/ · Copilot .github/prompts/ · Windsurf .windsurf/workflows/ · Codex ~/.codex/prompts (cosmos connect codex --write-user, as /prompts:cosmos-qa) · the plugin as /cosmos:qa
  • Your own playbooks become commands too: a master QA protocol or a runbook in the repo is found by itself (/master-qa-protocol), and /qa follows the QA one
how it works, inside

One loop, every agent.

Click any part to see what happens inside it: the steps, the numbers measured on a live repository, and the files that do it.

How cosmos works Agents feed cosmos through hooks, the watcher and MCP tools; capture writes the journal and observations; one dream at a time curates them into the ledger committed in git; the ledger comes back to every agent as the briefing, recall, the before-edit note and the Gate; releases and Claude Routines keep it running. how it works Every session feeds one memory; every session reads it back. agents Claude Code · Coworkhooks + MCP + plugin Codexplugin hooks · skills · MCP Cursor · Gemini · CopilotAGENTS.md · commands · MCP Claude Routinescloud: pr-review · dream · pulse into cosmos Hooks session start · each prompt before an edit · end of turn Watcher every agent's session files, parent folders, worktrees MCP tools remember · flare · recall · why asks the client its folders: another project → refused the loop Capture journal: one line per turn observations · secrets redacted ranges for the model to read Dream · one at a time the model curates what sessions said duplicates merged · contradictions to Verdicts · stale facts flagged recall@5 measured · metrics saved commits .cosmos to the branch Ledger, in git facts · rules · flares · lanes · Atlas playbooks · handoffs · metrics one markdown note each, with evidence git pull = the team has it back to agents Briefing Charter + top facts, ≤ 9,000 chars Recall each prompt · before each edit Gate · end of turn tests · file:line · open flares security · large-change scans what the team knows reaches every session · cosm◎s · recalled 3: … guarded notes that steer an agent are withheld · hidden Unicode and credentials stop the Gate · a dependency change needs its audit keeps itself current PyPI release daily check at a session start sha256 + import test .cosmos/vendor, committed repairs, once per version nobody pushes into a projecta bad release is refusedhooks · commands · listings git pull → click any part to open it
measured, not estimated · cosmos pulse

One live product repository, seven days.

Two people working with Claude Code, Codex and Cowork. Every number below is read from that repository's own .cosmos/ records or from running its hooks, by cosmos pulse --bench on 2026-10-01.

723agent turns recordedby 2 people; tests ran in 146 of them
2,085active team facts82 of them rules a person stated
0.81recall@5the right fact in the top five, over 45 evals
0.65before an editthe fact about the code being changed is shown
329tokens per promptmedian; facts reached 35 of 43 prompts
8,452characters at session startunder Claude Code's 10,000 hook limit
285–398 msper hookmedian, fresh process; 700–790 ms before the ledger cache
175flares50 fixed, 114 open, each with its file and line
37dreams31 curated by the model, 8,158 session turns read

Run it on yours: cosmos pulse --bench. A dream saves one report a day to .cosmos/ledger/metrics/.

steps to follow

Getting started

One person runs one command once. Everyone else clones. Capture, reading, dreams, the watcher and hook refreshes happen by themselves.

1
cosmos init, once

Creates .cosmos/ with the Charter, the Ledger, the first Atlas and the /atlas prompt; wires hooks at repo and user level (every worktree is covered), MCP configs and the instruction files of every agent; reads the sessions this repo already had, writes their journal, marks the recent ones for the model, and starts the first dream and the watcher in the background.

python3 -m pip install cosmos-dev
cd <your-repo>
cosmos init
cosmos flares import <findings.json>   # only if you have an audit document
2
Agree the Charter, then commit

Edit .cosmos/charter.md in a pull request — that is the team agreeing on one style. Commit and the memory becomes the team's.

cosmos charter edit
git push   # cosmos init already committed .cosmos/ and the agent wiring to this branch
3
Everyone else clones and opens their agent

No install, no setup — Claude Code, Codex, Cursor, Gemini CLI, Copilot, Cline or Cowork all read the same Charter, facts and tools. A committed wrapper runs cosmos from the repository. Sessions that were already open pick cosmos up on their next turn; Cowork gets the tools from the cosmos plugin.

git clone <repo> && cd <repo>
# open your agent: claude · codex · cursor . · gemini · …
4
Look, now and then

cosmos ui shows the live sessions, the ledger, the lanes, the flares and what waits for a human on Verdicts. Dreams run by themselves; commit .cosmos with your normal work and everyone gets it on the next git pull. Map a feature before coding with cosmos horizon "…" or on the Horizon page.

Want a fact or rule kept for certain? Type remember: never modify production schemas by hand or flare: /transitions has no role gate in any agent, or call cosmos_remember over MCP. Explicit rules always outrank inferred ones.
already have a codebase?

Link an existing project and its past sessions

Most projects already have months of history: AI sessions on several machines, an audit document, branches nobody has drawn. cosmos init brings the sessions in by itself; the rest is agreeing the Charter and committing.

1
Initialise

Reads every past session (all worktrees, subagents), writes their journal, marks recent history for the model, starts the first dream and the watcher.

cd <your-repo> && cosmos init
2
Bring in an existing audit, if there is one

If the file does not exist yet, cosmos asks before creating an empty one to fill in (--yes creates it without asking).

cosmos flares import <findings.json> --source <report-name>
cosmos flares add --from bugs.xlsx   # a list the team kept by hand: .csv .xlsx .txt
3
Look while the first dream finishes in the background
cosmos ui
4
Agree the Charter, commit on a branch off your base branch
cosmos charter edit
git push   # init committed .cosmos/ and the wiring to this branch; run it on a branch off your base branch to review it in a PR
5
Sessions that were already open, and Cowork

Nothing to restart in Claude Code: the next prompt carries the briefing the session missed. Cowork runs no hooks and reads no local MCP config, so it gets cosmos from the plugin: add this repository as a plugin marketplace and install cosmos. The tools appear with your next message. A project's own playbooks (a master QA protocol, a runbook) become commands for every agent by themselves; cosmos playbooks add qa starts one. /plugin is a command of the Claude Code CLI only: in the Claude desktop app use its Plugins screen, or run the two claude plugin lines below in any terminal.

# Cowork / Claude desktop app: Plugins → add marketplace → BiswajitBiswa/cosmos → install cosmos
# any terminal (same as /plugin … inside the Claude Code CLI):
claude plugin marketplace add BiswajitBiswa/cosmos
claude plugin install cosmos@cosmos
# Codex app: Plugins → add marketplace → BiswajitBiswa/cosmos → install cosmos (nothing else to run)
codex plugin marketplace add BiswajitBiswa/cosmos   # the same from a terminal
# a repository with cosmos lists the plugin itself (.agents/plugins/marketplace.json): Codex → Plugins → Install
6
Teammates
git pull   # then open your agent

Transcripts live in ~/.claude/projects/<repo path, slashes → dashes>/ (Claude Code), ~/.codex/sessions/ (Codex), ~/.gemini/ (Gemini). They are read, never stored; secrets are redacted. .claude/settings.local.json is personal and untouched; .cosmos/state/ is gitignored.

honest assessment

Advantages and disadvantages

Why it is a good fit

  • Nothing to run. No database, no server, no account — and no API key: the model is your existing Claude Code login.
  • Zero effort for developers after the first setup; the second person just clones.
  • One place for rules, facts and structure — inspectable as plain files, diffs and Obsidian notes.
  • Wrong facts cannot hide: evidence and age on every one. Stale diagrams cannot hide: drift is reported.
  • The review checklist stops being a person's job.
  • Privacy by construction: local-first, secrets redacted, transcripts never stored.
  • Works across agents through AGENTS.md, not only Claude Code.

Where it falls short today

  • Hooks extract nothing themselves: they mark the session range and write the journal; the model reads the conversation at dream time. That costs model calls (about one per 9k characters of session), so a busy team's dream takes minutes, in the background. With no model for three days the old heuristics keep what they can, and the dream says so.
  • The Atlas reads manifests and specs, not a code graph — no call chains, no dependency analysis inside the code.
  • The Gate checks that tests ran, not that they were the right tests or that they passed.
  • Capture and Gate hooks exist for Claude Code only; other agents read but do not write.
  • Memory is per repository; cross-repo recall inside the hooks does not exist yet.
  • Verdicts are trust-based; the audit trail is git history, not roles. No Jira integration.
why use this

The cost you pay today is invisible.

Nobody files a ticket for “rediscovered the same constraint as last week”, “the AI used a different style again”, or “the diagram was wrong”. It shows up as slower onboarding, repeated mistakes, review calls that repeat themselves, and a quiet erosion of trust in the AI tools. cosmos makes the knowledge, rules and structure that already exist in your team stay put — for the price of one init.

And it is safe to try. It writes one folder and a few lines into files you already have. Remove the hooks with one command and nothing else changes.

why we made this

Three months in, eight complaints, one cause.

We were building a product across several repositories with Claude Code. People overlapped on features, each told the AI a different style, product added features faster than the picture could hold, there was no architecture diagram anyone trusted, and every call repeated the same asks. A QA audit produced twenty-nine findings that lived in a document nobody reopened.

The tools we looked at either wanted a hosted service or solved one slice. We wanted the minimal whole: memory, rules, structure and a gate — versioned with the code, with nothing to operate.

The killer feature is not that the AI remembers. It is that the team stops repeating itself.

cosmos · MIT licence · Python 3.9+, standard library onlycosmos doctor checks a setup · cosmos ui opens the control room