The context your AI agents have been missing.
Celeborn Code gives every coding agent a persistent, tiered context substrate — so they stop forgetting your project the moment the window fills, and start picking up exactly where the last one left off.
Designed to work with Claude Code, Grok Build, Codex, Cursor, and just about any model you can think of…
Captures every turn — and rehydrates the next session.
Disposable sessions become your compounding asset.
Every AI coding session starts from amnesia: you re-explain the architecture, the decisions, the gotchas — burning tokens and time — and then a compaction or a restart wipes it and you do it again. Celeborn Code turns that forgetting into context that gets more valuable every turn, every agent, and every teammate you add.
The next session wakes up already knowing everything.
Your agents never forget.
Local-firstCeleborn Code fixes amnesia on your own machine. Run one agent or a whole local fleet — they all read and write the same local .context/, sharing one mind.
-
A tiered
.context/storeSeven tiers —
Hot,Warm,Cold,Distilled,Durable, anAutomatic Context Record, and a derivedIndex. Only the small Hot headline loads on every session start; everything deeper is reached on demand, so the footprint stays bounded no matter how much memory accumulates. -
Automatic rehydration
A Claude Code hook reloads the Hot tier at the start of every session and bridges compactions, so the agent resumes with full awareness and zero re-priming.
-
Mechanical capture
Every turn is recorded automatically. A stale hand-written state can never silently rot, because the machine keeps an always-current record beside it.
-
Local multi-agent telepathy
Run as many agents as you like on one machine — they share the same local
.context/and channel, so a finding by one is instantly known to all. No cloud required.
No network, fully offline — and Celeborn Code estimates the tokens and restarts it has saved you. Included in every plan, starting with the 7-day free trial.
Edit on one device — every other updates in seconds.
Your context, on every device.
Pro · $8 / seat / moYour fleet runs locally; Pro lifts your .context/ into hosted sync — so the exact same mind stays coherent across your laptop, desktop, even your phone, in real-time. It also unlocks the hosted kanban board.
-
Real-time hosted sync
Edit context on one device; every other device sees it within seconds — no git dance, no manual transport.
-
One context, everywhere
Your whole local fleet's
.context/stays identical on every machine you touch. Start on your desktop, finish on your phone. -
Unlimited projects & hosted board
Every project you run, hosted and synced, with zero setup and nothing to wire up by hand — plus the hosted kanban board, live at
celeborncode.ai.
$8 / seat / mo. Pro is about reach, not headcount — one seat covers every agent on your machine. Pick up on your phone exactly where your desktop left off.
One decision becomes everyone's context.
The whole team shares one context — across all models, agents, and IDEs.
Team · $12 / seat / moDrop a team into that shared mind and it stops being a tool and becomes institutional knowledge that writes itself.
-
Shared projects & shared context
Teammates' agents inherit the same living context. A decision one agent made is context every other agent has moments later — onboarding collapses from weeks to minutes, because the project explains itself.
-
Shared agent telepathy across people
Not just your fleet on the bus, but the whole team's. Agents coordinate across humans the way a great team does — nothing lost to a closed laptop or a forgotten Slack thread.
-
Admin & governance
Org-level controls, seat management, and a single place the team's accumulated context lives — redacted of secrets on the way up and protected at the database row.
$12 / seat / mo: everything in Pro, plus shared projects, shared context, org admin, and the shared agent telepathy bus. Enterprise adds SSO/SAML, custom terms, and volume pricing.
Never re-explain your project again.
Every session lands pre-hydrated and ends with a paste-ready handoff. Weeks-old decisions are one command away — so you spend your tokens building, not re-priming.
Orient — auto-rehydrate
A SessionStart hook prints the Hot tier so the agent wakes with full situational awareness. No re-priming, ever.
Handoff
celeborn handoff writes a paste-ready resume prompt — the cheapest possible compaction: zero history cost, full continuity into a fresh thread.
Decision archaeology
celeborn why "<topic>" surfaces the decision, its date, and the rationale from weeks ago. It remembered why.
Memory-aware blame
celeborn blame <file> fuses git blame with the decisions, journal, and learnings that cite the file.
Standup & changelog
celeborn standup / changelog — a mechanical "what happened" digest (1d / 7d) from done cards, commits, and the journal.
Persistent statusline
A quiet 🏹 Celeborn line in the UI chrome shows tokens banked and the live context size, every turn.
The system keeps itself current — so you don't babysit it.
Memory updates itself in the background, the window stays light, and a compaction can never lose your place. You keep your hands on the work.
Automatic Context Record
A Stop hook records a faithful account of every turn — your prompt, the assistant's text, every tool call and output — deterministically, no model in the loop, secrets redacted on the way in. Only a tiny digest loads on orient.
Gentle /clear reminder
UserPromptSubmit reads the live window size and nudges you to /clear once it fills — clearing is safe because the Hot tier reloads automatically.
Panic-save & restore
PreCompact snapshots your authored tiers before the window is summarized; celeborn restore brings them back. Reversible compaction insurance.
Always-current safety net
Even if a hand-written brief drifts, capture + search recover what actually happened. Fires for every session — falling back to a global store when you're outside a repo.
Celeborn Code knows your whole codebase, instantly.
Alongside its episodic memory of what you were doing and why, Celeborn Code keeps a local graph database of your entire codebase — call chains, routes, impact, dead code, architecture. The agent answers structural questions through one pre-approved, never-prompting surface instead of a stream of grep and Bash cycles that each interrupt you with an "Allow" click. 100% on your machine — your code never leaves it.
fewer tokens — five structural queries: ~3,400 vs ~412,000 via file-by-file search (a 99.2% reduction).
across real-world repositories: 83% answer quality, 10× fewer tokens, 2.1× fewer tool calls vs. file-by-file exploration.
programming languages, sub-millisecond queries, a single static binary — indexes the Linux kernel (28M LOC / 75K files) in ~3 minutes.
-
Flow first — no permission prompts
Structural questions route through safe, pre-cleared query tools, so the permission-prompt interruptions that break a vibe coder's flow simply stop happening. This win is independent of codebase size.
-
Speed
Sub-millisecond structural answers; an average repo indexes in milliseconds. The agent stops spending turns rediscovering structure it could just ask for.
-
Tokens
The agent stops reading whole files to understand structure — it queries the graph and reads only the lines that matter.
Built from a tree-sitter AST with hybrid semantic type resolution. Engaged automatically when a project warrants it — fully local, zero setup.
A bounded context footprint — no matter how much you remember.
Only the small Hot tier enters context by default. Everything deeper is reached on demand — snippets and file:anchor pointers, never whole files. Resuming gets cheaper over time, not more expensive.
Size-budgeted Hot tier
Only the Hot tier loads by default, and it's size-budgeted (tunable in .celebornrc). Day-1 Orient cost ≈ day-365 Orient cost.
Full-text recall
celeborn search — SQLite FTS5 over everything you've banked. The index is derived, gitignored, and rebuilds in ~35ms on any device.
Tiered forgetting
celeborn promote distills journal → learnings → durable and archive ages out the journal — so the Hot tier never bloats.
Honest numbers, never inflated.
Celeborn Code estimates what it has saved you — read-only, conservative — and lets you flex it. One honest subscription — $8/seat/mo after a 7-day free trial — with zero third-party dependencies.
Token economy
celeborn metrics — an honest estimate of tokens saved (everything in .context/ minus the Hot tier, summed over load events) and restarts avoided.
$ Wrapped brag card
celeborn flex --tweet — a shareable card turning tokens saved into dollars and restarts avoided.
Project + fleet savings
celeborn savings — running totals for this project and the whole fleet, feeding the board's economy bar.
A shared mind for a whole fleet.
A live kanban board is the source of truth; agents claim work on receipt, register their edits, and broadcast discoveries. Coordinate a swarm across repos, models, and devices without anything getting lost.
auth-sweep
Audit every API route for missing auth checks and propose fixes
134 processed · 57 found / 2 missed (of 168)
- graph142✓
- grep38✓2✗rl3
- tests61✓
- ✗ shard-04 4✓ 7m11s infra/terraform/ ⚠ rate-limited: graph 41s
- ◐ shard-03 3✓ 6m40s 1.4/m vendor/legacy/*.php 14s
- ● shard-01 5✓ 4m12s 4.3/m app/api/billing/route.ts 3s
- ● shard-02 9✓1✗ 5m02s 4.4/m lib/auth/session.ts 2s
- ● shard-07 6✓ 3m30s 4.0/m app/api/webhooks/stripe/route.ts 1s
- ✓ shard-05 12✓ 3m58s — complete
- ✓ shard-06 8✓1✗ 4m20s — complete
- ✓ shard-08 10✓ 4m48s — complete
Hosted kanban board
Live · celeborncode.aitasks.md is the source of truth. A local viewer ships with the CLI; the hosted multi-tenant board at celeborncode.ai/<owner>/<project> adds real-time sync with full edit/add/delete parity (Pro).
Claim-on-receipt
Paste a card's ⟨celeborn:tN⟩ marker into any agent and a UserPromptSubmit hook auto-claims it — TODO → DOING, owner set. Semi-telepathy.
Agent self-ID & file touches
celeborn identify labels every claim and edit with which agent and model did it; celeborn touch registers who's editing what to prevent collisions.
Fleet dashboard
celeborn fleet register → live status across every repo: who's working, who's stuck, who's idle.
Run tracker — swarm heartbeat
celeborn run start|beat|status|watch — a real-time dashboard for autonomous Elves swarms, with a shared blackboard so one worker's discovery propagates to all.
Agent telepathy bus
TeamA shared channel so discoveries propagate across agents and devices instantly — plus per-agent outboxes that the hook drains each turn.
The agent advises you on its own workflow.
Celeborn Code watches how you work and quietly suggests improvements — throughput, quality gates, and collapsing repeated approval prompts into reusable rules.
Skill Advisor
celeborn advise — throughput and quality recommendations (test coverage, review gates, security review, deploy/verify), rendered per-harness and dismissable.
Permissions advisor
celeborn permissions --suggest|--apply — collapses repeated approval prompts into reusable wildcard rules, so the "Allow" clicks stop adding up.
Health checks
celeborn doctor / integrity / version --check — memory-drift, secret scan, install integrity, and update notices.
Plugged into the tools you already use.
Start with a free trial. Grow into a shared mind.
Starts with a 7-day free trial — $0 today, cancel in one click. The entire local CLI (tiered memory, auto-rehydration, capture, search, local kanban board, and Elves) plus hosted cross-device real-time sync, unlimited projects, and the hosted kanban board.
Everything in Pro, plus shared projects, org admin, shared context, and the shared agent telepathy bus.
Everything in Team, plus SSO/SAML, custom terms, and volume pricing. Ask in the support chat.
Disposable, forgetful sessions become a compounding asset.
Celeborn Code turns disposable AI sessions into context that gets more valuable every turn, every agent, and every teammate you add.
What other agents say about working with Celeborn Code — in their own words.