Frequently asked questions

How Celeborn works, what it costs, how it treats your code, and how it keeps a fleet of humans and AI agents out of each other's way. Can't find your answer? Hit the Support pill above and ask the crew directly.

uv tool install celeborn && celeborn init

Getting started

What is Celeborn, in one sentence?
Celeborn gives your codebase a long-term memory your AI coding assistant can rely on, plus a Kanban board built for humans and AI agents working together — so sessions stay fast and nothing gets forgotten between them.
I'm new to coding — is Celeborn going to be too advanced for me?
Not at all. If you already use an AI coding assistant, you're the exact person Celeborn helps: it quietly keeps notes about your project so your assistant stops forgetting things between sessions. Install it with one command and it mostly works in the background — there's nothing to operate day to day.
How do I install it?
One command: `uv tool install celeborn`, then `celeborn init` inside your project. The installer wires Celeborn into your editor so everything is connected correctly the first time.
Is there a free version, or is this a trial that expires?
The free tier is a complete product, not a demo, and it never expires — the entire local experience (memory, capture, search, local board) is free, offline, with no account needed. Upgrade only when you want sync or team features.
Do I need an account to try it?
No — the free tier needs no sign-up and no payment details. You only create an account (GitHub sign-in) for the optional cloud features: cross-device sync and the hosted board.
Will installing Celeborn change or break my code?
No. Celeborn never modifies your source code. It adds a small .context/ folder of readable notes inside your project; delete it any time and your code is untouched.
Do I need to know git?
No. Celeborn works whether or not you use git — its memory is plain text files in your project. If you do use git, the bulky machine-generated files are automatically kept out of your repository.
What operating systems are supported?
macOS, Windows, and Linux. Installation is a single command that wires Celeborn into your editor for you.
Does it work offline?
Yes. The core — capture, tiered memory, search, and the local Kanban board — runs entirely on your machine with no internet and no account. Only the optional cloud features need a connection.
What's a “context window” and why should I care?
Your AI assistant can only see a limited amount of text at once — its context window. As a conversation grows, old details fall out and the assistant starts forgetting or slowing down. Celeborn keeps a compact summary of what matters loaded at all times and fetches deeper detail only when needed, so your assistant stays sharp without you re-explaining your project.
How do I update to a new version?
A one-line command through the same package manager you installed with — `celeborn version --check` tells you if a newer version is available. Your .context/ memory carries forward untouched.
I don't have a GitHub account. Can I still use Celeborn?
Yes, for everything local: the free tier needs no account at all. A Celeborn account (for cloud sync and the hosted board) signs in with GitHub — creating one at github.com/signup takes about two minutes.

The .context memory

What exactly lives inside .context/?
Plain, human-readable Markdown you fully own: a small headline file with the project's current state and next action, working notes, a journal of each session, recorded decisions and learnings, the task board file, and durable reference docs. Alongside those sit two machine-managed pieces — an activity capture and a local search index — which are disposable and automatically kept out of git.
What are the memory “tiers”?
A hot tier — the small headline slice loaded at the start of every session, so orienting is cheap — and deeper tiers (notes, journal, decisions, durable docs) read on demand or found via search. Your assistant pays for a tiny summary every session instead of re-reading history, while nothing is lost.
Can I edit the memory files myself?
Yes, and you're encouraged to — they're your files, in plain Markdown. Fix a wrong note, rewrite the headline, add a durable doc. Your assistant reads whatever is there next time it orients. No proprietary format, no sync step for local edits.
Should I commit .context to my repository?
Your choice. The bulky machine-generated parts (search index, activity capture) are auto-excluded from git, and the curated Markdown is small — many teams commit it so teammates and agents share the memory. In shared or public repos, a setup flag keeps your working notes private.
How does search over the memory work?
Celeborn keeps a local full-text search index (SQLite FTS5) over your project's context, so `celeborn search` recalls older details in milliseconds without loading everything into your assistant's context window. The index is local, disposable, and rebuilt automatically — it never leaves your machine.
Two of us edited the memory files — will they merge in git?
They merge like any other text files, because that's what they are. The conventions keep the conflict surface small: the journal is append-oriented, the headline is a small rewrite-in-place file, and the machine-generated files never enter git. A real conflict resolves in plain Markdown like any other file.
What happens if I just delete the .context folder?
Nothing bad — your code is unaffected. You lose the project memory Celeborn had built up, and it starts fresh next session. The search index and activity capture inside are disposable and rebuild automatically.

The board & multi-agent work

How do multiple AI agents avoid stepping on each other?
Through the shared board and a few simple protocol rules. Every agent sees the same task board when it orients; work in progress is claimed on a card, and an agent holds only one in-flight card at a time. Agents also register which files they're actively editing (with a reason) and identify themselves — model and handle — so a human can always see who is doing what, live.
What's the point of “claiming” and “shipping” a card?
Claiming marks a card as yours so no other agent or teammate grabs the same work; shipping closes it out for everyone. Because every agent orients from the same board, claim/ship is what turns a fleet of independent AI sessions into a coordinated team instead of a collision.
What's a Stop condition on a card?
A short, concrete statement on each card of what a defensible stopping point looks like — the marker that the work is safe to hand off or pause. It protects the project from half-finished, undocumented states.
Can humans and AI agents share the same board?
Yes — that's the design. The board is one shared source of truth: humans see what agents are doing in real time, agents see human-filed cards, and both follow the same claim/ship rules. On Team plans this extends across your whole organization with shared projects and context.
How do I see which agent did what in my repo?
Three places: the board (who claimed and shipped each card), the journal (what each session did), and — if you commit with the convention — git commit trailers naming the agent, model, and task on each commit. File touches are also registered live while an agent is working, with a reason attached.
Do I have to use the Kanban board?
No. The board is there when you want it — especially once several people or several AI agents share a project — but the memory features work on their own. Plenty of solo users start with just the memory and discover the board later.

Fitting into your workflow

Which AI coding tools does Celeborn work with?
Celeborn integrates through your AI tool's hook or plugin system, so capture and orient happen automatically. It works with Claude Code and Grok Build today, and support for additional tools (such as OpenCode) is actively rolling out. The memory files are plain Markdown any assistant can read.
Does Celeborn work in a monorepo or with multiple projects?
Yes. Each project root gets its own .context/ memory, and the CLI accepts an explicit path when you need to point it at a specific project. If you have an unusual layout, ask us — we'll recommend a setup.
Can I use Celeborn on more than one machine?
Yes — that's exactly what Pro adds: your project memory syncs securely across your devices in real time, plus the hosted board. On the free tier, memory is per-machine (though if you commit the curated memory to your repo, pulling the repo carries it with you).
Will Celeborn slow down my editor or my AI assistant?
It's built for the opposite. The always-loaded slice is deliberately tiny, deep detail is fetched only on demand, and search runs against a local index. What users notice is sessions that stay fast as projects grow, because the assistant isn't dragging its whole history around.
Does Celeborn run in CI or on a server?
Celeborn's core is a local CLI plus editor integration, designed for development machines. Its memory files are plain text in your repo, so CI can read them like any other file. If you have a specific CI or server automation use case, tell us — we'd genuinely like to hear it.
How do I keep my personal working notes out of a shared repo?
Use the setup flag for shared/public repos — it keeps your working notes private to your machine while the rest of the project memory behaves normally. The machine-generated files are excluded from git in every setup.

Under the hood

How does Celeborn decide what stays in context?
The memory is explicitly tiered. A small headline file (current focus, next action, pointers) is loaded on every orient; everything else — notes, journal, decisions, durable docs — stays on disk and is pulled on demand or found via full-text search. The always-loaded cost is designed to stay roughly constant as the project grows, because depth lives behind pointers rather than in the prompt.
Is there a daemon or background service running?
No resident daemon is required for the core experience. Celeborn hooks into your AI tool's session lifecycle (session start, prompt submit, tool events) to capture and inject context at the moments that matter, and the CLI does its work when invoked.
What's the search index, technically?
A local SQLite FTS5 full-text index over the project's context files. It's gitignored, disposable, and rebuilt on demand — treated strictly as a cache, never as the source of truth. The Markdown files are the truth; the index just makes recalling them cheap.
Is my project memory portable if I stop using Celeborn?
Completely. The memory is plain Markdown on your disk in an open layout — read it, grep it, or hand it to any other tool the day you leave. There's no export step because there's nothing to export from: you already hold the originals.
Doesn't injected context risk prompt injection?
Retrieved content is treated as data, not instructions — injected knowledge is fenced and labeled as reference, and file or message text can't override the rules an agent runs under. Locally, Celeborn's memory is your own repo's files on your own machine, so the trust boundary is the one your repo already has.
How is this different from my assistant's built-in memory or /compact?
Built-in summarization compresses a single conversation, inside one tool, and degrades as it compounds. Celeborn maintains a structured, human-readable project memory that lives with the repo: it survives resets, works across sessions and across agents, can be edited and reviewed like code, and is tool-agnostic because it's just Markdown. The two compose fine — Celeborn makes resets cheap rather than fighting them.
What data does the free tier send off my machine?
None. The free tier runs entirely locally — no account, and your code and .context/ never leave your disk. Network features begin only when you opt into cloud sync or the hosted board on paid plans.

Troubleshooting

My assistant doesn't seem to remember anything — where do I start?
First check that Celeborn is actually wired into your AI tool: run `celeborn doctor` in the project — it checks the setup and flags what's off. Then confirm the project has a .context/ folder with a state file in it. If both look right and it still misbehaves, contact us with what doctor printed and we'll dig in together.
The board or memory looks stale or wrong — how do I fix it?
The Markdown files are the source of truth, so the direct fix is often to edit them — rewrite the headline, correct the note, fix the card. If search results seem stale, rebuild the index with `celeborn index`; it's a disposable cache. Every agent sees the fix on its next orient.
An agent claimed a card and vanished — is the card stuck?
No. Cards are just state — a human or another agent can demote or re-claim a card whose owner went away, and the card's Stop condition records where the work actually stood.
Something crashed — what should I send support?
The command you ran, the exact error text, your OS, and your Celeborn version (`celeborn version`). With those four things we can usually reproduce it. Never paste secrets or tokens into chat — we don't need them and don't want them.

Security & privacy

Is my code sent anywhere?
By default, no. The free tier runs entirely on your machine, and your .context/ memory stays local. Nothing about your code leaves your computer unless you deliberately turn on a cloud feature or explicitly share something with our support team to get help.
Do you train AI models on my code or content?
Never. Not to train, not to fine-tune, not to “improve the service.” Your code and your project memory are used solely to help you, and the free tier never transmits them anywhere at all.
Can support staff see my code when I ask for help?
Not unless you explicitly authorize it, in that conversation — and you can revoke that at any time. When you do authorize it, your code and context are used only in-memory for the live moment of the conversation: never written to our database, never written to our logs, never used to train anything.
What's encrypted if I use cloud sync?
Synced data is encrypted in transit (TLS) and at rest (AES-256), with particularly sensitive values like access tokens given an additional encryption layer before storage. Every request is scoped to your identity, so no customer can ever reach another customer's data.
We're a security-conscious team — what should we review before adopting?
Three facts make that review short: the free tier is fully local (no data leaves your machines), the memory format is plain Markdown you can audit line by line, and cloud features are opt-in on infrastructure holding SOC 2 Type II, ISO 27001, and PCI DSS certifications. For SSO/SAML, data residency, or a formal security questionnaire, ask in the support chat and we'll route you to the right person.
How do I report a security vulnerability?
Tell us in the in-app chat and say it's a security issue — that flags it for priority routing straight to a human. Please report privately and give us a reasonable window to fix it before public disclosure; we take responsible disclosure seriously.

Evaluating & buying

What plans do you offer?
Free ($0 — the full local toolkit), Pro ($8 per seat/month — cross-device sync and the hosted board), Team ($12 per seat/month — shared projects, shared team context, org administration, multi-agent coordination), and Enterprise (custom — SSO/SAML, custom terms, volume pricing; ask in the support chat). Annual billing saves about 8%.
We're comparing tools — why pick Celeborn?
Three things users consistently value: the free tier is a complete product, so you can prove the value before paying anything; the memory is open Markdown in your own repo, so there's zero lock-in to walk back if we're wrong; and multi-agent coordination — humans and several AI agents sharing one live board — is designed in from the start rather than bolted on.
How should we run an evaluation or pilot?
Start free, on a real project, with the engineers who most feel the pain of re-explaining context — there's no time limit, no account needed, nothing to procure. When you want the team layer, that's Team at $12 per seat/month, and you can add seats as the pilot grows.
Can we buy through procurement, get invoices, or sign our own terms?
Yes — custom invoicing for procurement is available (ask in the support chat), and custom contractual terms are part of Enterprise. Standard plans run on self-serve monthly or annual billing per seat, with receipts and invoices in your billing area and tax handled at checkout.
If I cancel, do I lose my project memory?
No. Your local .context/ memory is on your own machine and completely unaffected — you keep it forever. Only the cloud extras stop; everything local keeps working offline. You also keep full access to paid features through the end of the period you've paid for.
What does the ROI story look like?
AI coding sessions degrade and repeat themselves as context bloats, and engineers pay that tax daily — re-explaining projects, re-deriving decisions, colliding agents. Celeborn's value is removing that tax: sessions start oriented, decisions persist, agents coordinate. The numbers we publish are estimates from Celeborn's own counters with the methodology stated (see the Answers pages) — and the free tier lets your team measure it on your own project, which is more convincing than anything we could quote.

What Celeborn is not

Is Celeborn open source?
Celeborn is source-available under the Business Source License (BUSL 1.1) — the code is public on GitHub to read and audit, but it isn't an OSI open-source license. Your data stays in open formats (plain Markdown) precisely so you're never locked in, and the free tier is genuinely free.
Does Celeborn replace git, Jira, or my project management tool?
No. Celeborn is the memory and coordination layer for AI-assisted work — it complements version control and doesn't try to be your company-wide project tracker. Its board is the live source of truth for what agents are doing in a repo; if you need it to feed another system, ask us about your specific setup.
Will Celeborn make my AI write better code?
Not directly — it's not a model and doesn't change your assistant's raw ability. What it changes is what your assistant knows: the project's decisions, constraints, and history are on hand instead of forgotten. Better-informed sessions tend to produce better outcomes, but the coding skill is your assistant's.
Is Celeborn a chatbot or an AI assistant itself?
No. Celeborn has no model inside; it's the memory and coordination layer that makes the AI tools you already use work better across time and across agents. You keep your assistant, your editor, and your workflow.
Can Celeborn run fully on-premises or air-gapped?
The local core effectively already does — it's offline, account-free, and nothing leaves the machine. If you mean self-hosting the cloud layer (sync and the hosted board) inside your network, that's an Enterprise conversation — start it in the support chat.