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 chat pill in the corner and ask the crew directly.

uv tool install celeborn-code && 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. Once you subscribe, your assistant runs the install for you — day to day there's almost nothing to operate.
How do I install it?
Start at celeborncode.ai/start: pick the AI you already use (Claude Code, Codex, or Grok Build), complete checkout, then paste one prompt into that assistant. Your agent runs the guided install — Node, the Celeborn pack, login, and project wiring — so you don't type package-manager commands yourself. Power users who already have the CLI can still install via Homebrew, Scoop, or `uv tool install celeborn-code`, then run `celeborn init`. Begin at /start
I don't have an AI coding assistant at all. Can I still use Celeborn?
Easy includes DeepSeek V4 Flash, so it works without another AI subscription. After setup, you may optionally connect Claude Code or Codex and select that engine for a card. Those engines keep their own login and native permissions. Grok is not an Easy launch engine. Get Claude Code
Do I have to pay for an AI subscription or API to use this?
Easy is $20/month and starts on DeepSeek V4 Flash with $8 of included monthly model usage. The $8 limit is a hard cap with no usage overage. You may optionally connect Claude Code or Codex; that provider bills its own subscription, retains its native permissions, and never gives Celeborn your login credentials. Junior, Senior, and Chief add Trusted Flow with larger model budgets.
I don't have a project yet — can I still try Celeborn?
Yes. Start at celeborncode.ai/start and let your agent finish install; on a fresh setup Celeborn can create a small orientation project so you learn the board and the memory on something real. Your actual project folder can come later.
I've never used a terminal. Can I really do this?
Yes — the V1 path is agent-led. You paste one prompt into Claude Code, Codex, or Grok Build after checkout; that agent runs the guided installer for you. You don't need to learn package managers first. If anything looks scary, open the support chat and we'll walk it with you live.
Is there a free version, or is this a trial that expires?
There is no permanent free tier and no live-product trial in the current public funnel. Before you pay anything, you can watch the seven-card guided demo — a read-only recording with no account and no card. When you're ready, Easy starts at $20/month with DeepSeek V4 Flash and an $8 hard monthly cap, with no usage overage. Cancelling is one click in your billing portal, and your .context/ memory stays on your disk as plain files either way.
Do I need an account to try it?
To watch the 7-card demo, no — it's a read-only replay with no account and no card. To subscribe, yes: the web path is celeborncode.ai/start → account → card at checkout, where your first month of membership is charged that day. Cancel in one click any time from your billing portal. Start at /start
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 memory folder is automatically kept out of your repository entirely, so it never shows up in your commits.
What operating systems are supported?
macOS, Windows, and Linux. After checkout, your AI agent installs and wires Celeborn for you on the machine where that assistant runs.
Does it work offline?
Yes. The engine — capture, tiered memory, search, and the local Kanban board — runs on your machine, and your subscription check is a small signed receipt cached locally with a multi-day offline grace, so a flight or a weekend off-grid never locks a paying user out. Your code and memory never need a connection; only sync and the hosted board do.
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 — a Celeborn account doesn't require GitHub at all: your email is your identity. `celeborn register` creates an account with email + password (MFA supported), and the hosted board signs in with email too. If you do have GitHub, you can connect it to your account as an optional extra sign-in.

Installing & install troubleshooting

I don't have Python, Homebrew, uv, or any of these tools. What do I install first?
If you're on the normal path, nothing: after checkout you paste one prompt into Claude Code, Codex, or Grok Build and that agent installs Celeborn for you. If you're installing the CLI yourself: on macOS with Homebrew and on Windows with Scoop, Celeborn is a standalone binary — no Python. On a machine with truly nothing, install uv first (docs.astral.sh/uv), then `uv tool install celeborn-code`. Stuck? Ask in the support chat.
How do I install with Homebrew?
`brew install cloud-dancer-labs/celeborn/celeborn` — standalone native binary, no Python. Then run `celeborn init` inside your project. Most buyers never need this: the post-checkout agent prompt does the install.
Older instructions say `pip install celeborn` (without the -code) — is that the same thing?
Yes — the package was renamed on PyPI: `celeborn-code` is the current name, and the old `celeborn` name is deprecated. The old name now holds a small pointer release that simply pulls in `celeborn-code`, so a stale `pip install celeborn` still lands the real thing. Either way, the command you run is `celeborn`. For anything new, use `uv tool install celeborn-code` (or `pip install celeborn-code`) — note that `uv tool install` and `pipx` need the full `celeborn-code` name.
I installed it but the terminal says “celeborn: command not found” (or “not recognized” on Windows).
Almost always PATH — and the number-one fix is simply opening a new terminal window, because a terminal opened before the install doesn't see it. If it persists: uv users run `uv tool update-shell` then open a new terminal; pip users are usually better off reinstalling with `uv tool install celeborn-code`. Verify with `celeborn version`.
pip refuses with “externally-managed-environment” — is that a bug?
No — newer Python setups (including Homebrew's) block system-wide pip installs to protect themselves. Install Celeborn as an isolated tool instead: `uv tool install celeborn-code` (or `pipx install celeborn-code`). Please don't force it with --break-system-packages.
On Windows, typing python or pip just opens the Microsoft Store.
Those are Windows's stub aliases — Python isn't actually installed. You don't need it: Scoop installs a standalone binary (`scoop bucket add celeborn https://github.com/cloud-dancer-labs/scoop-celeborn`, then `scoop install celeborn`). If you specifically want the Python route, install from python.org and tick “Add python.exe to PATH” in its installer.
PowerShell says “running scripts is disabled on this system.”
That's the PowerShell execution policy blocking an install script. Run `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser` — it affects only your own user account — then retry. If a company group policy overrides it, download the release binary directly from GitHub Releases instead (no script involved) or loop in your IT.
winget says “No package found matching input criteria” (or winget itself is missing).
Right now that's expected: Celeborn's winget listing is still in Microsoft's review queue, so the package isn't installable from winget yet. Use Scoop instead (`scoop bucket add celeborn https://github.com/cloud-dancer-labs/scoop-celeborn`, then `scoop install celeborn`) or `uv tool install celeborn-code`. Once the listing merges, `winget source update` followed by `winget install ThotTechnologies.Celeborn` will work.
macOS says it “cannot be opened because the developer cannot be verified.”
That's Gatekeeper reacting to a directly-downloaded file. The package-manager installs (Homebrew, uv, pip) don't trip it, so they're the recommended route. If you deliberately downloaded a release binary and trust it: right-click → Open, or System Settings → Privacy & Security → “Open Anyway.” On a managed work Mac, follow your IT policy.
Windows SmartScreen says “Windows protected your PC.”
Same story as Gatekeeper on the Mac: a directly-downloaded .exe. Prefer Scoop (or winget once our listing clears Microsoft's review), which doesn't trigger it. If you deliberately downloaded our release binary and trust it, “More info → Run anyway” is your call — and on a work machine, IT policy wins.
Our corporate network intercepts SSL and the install fails with certificate errors.
Classic corporate TLS interception — the proxy re-signs traffic with a company certificate your tools don't trust yet. Set your proxy variables (HTTPS_PROXY), ask IT for the company root CA bundle, and point Python tooling at it via SSL_CERT_FILE / REQUESTS_CA_BUNDLE (pip: `pip config set global.cert <path>`). Paste the exact error in the support chat — never tokens or passwords — and we'll walk through it together.
Do I need admin rights to install Celeborn?
Not on the recommended paths: uv installs everything into your home directory, pip user installs do too, and Scoop is user-scoped on Windows. That makes `uv tool install celeborn-code` the friendliest route on locked-down work machines where you're not an administrator.
Anything special for Apple Silicon vs Intel Macs?
Both are supported — builds exist for arm64 (Apple Silicon) and x86_64 (Intel). If you ever see “bad CPU type in executable,” the binary doesn't match your chip: check with `uname -m`, then reinstall via Homebrew or use `uv tool install celeborn-code`. A Terminal set to “Open using Rosetta” can also cause mismatched installs on Apple Silicon — turn that off for daily use.
Will Celeborn run on a Windows ARM laptop (Surface, Snapdragon)?
The Windows binary is built for x86_64; Windows 11 on ARM usually runs it fine through its built-in x64 emulation. If it won't start, the Python route runs natively: install uv, then `uv tool install celeborn-code`. Either way, tell us how it goes in the support chat — ARM reports genuinely shape our packaging priorities.
I use conda/pyenv and celeborn works in one terminal but not another.
It was installed inside one Python environment, so it disappears when that env isn't active. Install it as an isolated tool instead — `uv tool install celeborn-code` — which lives on your PATH regardless of the active env. Check `which celeborn` (macOS) or `Get-Command celeborn` (Windows) points somewhere stable, and restart your AI tool after PATH changes.
I installed Celeborn in WSL but my AI tool runs on Windows (or the reverse) and nothing happens.
WSL and Windows are separate environments with separate installs — hooks fire where your AI coding tool actually runs. Install Celeborn on that same side: tool on Windows → install in PowerShell; whole workflow inside WSL → install inside WSL. Project files are visible from both sides, but the wiring belongs to the side running the tool.
I ran celeborn init in the wrong folder. How do I redo it?
No harm done. Delete the stray .context/ folder it created, cd into your actual project, and run `celeborn init` again — it's idempotent and resumable, so re-running is always safe.
Can I just copy the .context folder and config from a teammate instead of installing?
That gets you the scaffold but nothing will fire: the hooks invoke the `celeborn` command, so the CLI must actually be installed on your machine. Install it by any route above, verify with `celeborn version`, then run `celeborn init` in the project — it keeps what's already there.
The sign-in during setup fails (no browser, or my company blocks it). Am I stuck?
Not at all: run `celeborn init --no-login` to finish the wiring and scaffolding, then `celeborn login` from any terminal once you can reach a browser — everything unlocks the moment you sign in. Nothing about the install is lost by doing it in two steps.
The install guide I found mentions Spark and a “remote shuffle service” — is that you?
No — that's Apache Celeborn, an unrelated big-data project that shares the name. This Celeborn is the coding-agent memory tool at celeborncode.ai: start at /start and paste the post-checkout prompt into your AI assistant, or install the CLI yourself (`uv tool install celeborn-code` then `celeborn init`). Source: github.com/cloud-dancer-labs/celeborn-code.
How do I know the install actually worked?
Three checks, in order: `celeborn version` proves the command is on your PATH; `celeborn doctor` inside the project verifies the wiring end to end and flags anything off; then open your AI tool in the project and say hi — it should orient from the .context/ memory. If doctor is clean and it still doesn't, ask in the support chat with doctor's output.

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. The whole folder is private to your machine: always gitignored, never committed.
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?
No — and Celeborn doesn't offer the option. .context/ holds your prompts, notes, and working memory, so committing it to a repo that is (or ever becomes) public would leak all of that permanently into git history. It's always gitignored by design. Your memory travels between your machines through your account and `celeborn sync` — never through git.
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 conflict in git?
They never meet in git — .context/ is always gitignored, so each machine keeps its own local memory and there's nothing to merge. Sharing across people is a membership feature: Junior, Senior, and Chief can share projects through your account, with the hosted side reconciling changes.
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. Shared projects are included with Junior, Senior, and Chief.
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.

The Spine discipline

What is Spine programming?
Spine programming is Celeborn's working discipline: give AI-built software a human-visible, long-term, ordered project structure — strong pre-planning plus persistent context — so powerful models produce a coherent system instead of a brilliantly coded blob. Two pillars: a strictly ordered backlog where the next card is always startable verbatim (the Spine), and tiered persistent memory so no session ever starts blind.
Why does Celeborn have its own vocabulary?
Because it's a new way of working, not just a new tool. When AI agents write most of the code, sprint-and-standup vocabulary describes problems that no longer exist and misses the ones that do — like keeping a project coherent across hundreds of short AI sessions. Each term (Spine, Stage, Ledger, Stop condition, orient, checkpoint, touch) names something real in the discipline.
What is the Spine?
Your TODO column turned into a strictly ordered, dependency-aware contract: cards are inserted in order, each carries a brief, real blockers, and a Stop condition, and the top card must always be startable by a fresh agent with zero context beyond a quick orient. It's what keeps a long project upright — one coherent, human-visible line of intent that survives any individual AI session ending.
What is the Stage?
The DOING column grown into a live workspace: each in-progress card is a window onto a running agent session — who's working, what's rolling, what needs you. The fully live Stage view is rolling out; today's board already shows live DOING cards with owners, progress, and context gauges.
What is the Ledger?
The Done column compressed into a receipt roll — one line per finished card, each an expandable audit trail. Finished work is evidence, not furniture: out of your way, never uncheckable.
What is the ship ritual?
The discipline's core rule: you may not ship card N until card N+1 is startable verbatim. The agent finishing a card — while it still holds all the context — is responsible for leaving the next card ready: brief written, blockers wired, Stop condition real. Discipline at ship time is what lets a project keep moving with no meetings and no re-explaining.
What are orient and checkpoint?
Orient is how every session starts: reading a small, always-fresh headline of the project (focus, next action, open threads) instead of re-reading everything. Checkpoint is the matching duty at the end: rewriting that headline before the session clears, so the next one starts cheap. Together they're the promise that no context is lost between sessions.
How is this different from kanban or Agile?
Classic kanban manages human attention (WIP limits, hand-offs); Agile manages human replanning cadence (sprints exist because humans replan expensively). When agents do the work, those scarcities mostly vanish — the real scarcities become human decision bandwidth, agent context windows, and card readiness. Spine programming manages those instead, keeps kanban's visual board, and drops the ceremony.
Does Celeborn have a constitution?
Yes — the Vibe Constitution and the Celeborn Bill of Rights: ten rights of the coder (Flow, Done, never-be-ruined, plain speech, command…) and the commandments that bind Celeborn's builders to them. It restrains us, not you — every right names the measure by which our violation of it is counted. Read the Vibe Constitution
What's the “brilliantly coded blob” problem?
Frontier models write excellent local code. Run many of them across weeks of short sessions with no shared long-term structure and you get excellent local code that's globally incoherent — duplicated concepts, drifting conventions, no auditable line of intent. It's a structure failure, not a model failure; the spine (ordered intent) and tiered memory (persistent context) are the structures that prevent it.

Fitting into your workflow

Do I have to give up Claude Code?
No. Celeborn installs into Claude Code as a CLI plus hooks, so there is nothing to switch to. You keep your terminal, your workflow, and your own Claude subscription in Settings powering the engine. The hooks add persistent .context/ memory and the board around the sessions you already run. Celeborn for Claude Code
Which AI coding tools does Celeborn work with?
Celeborn integrates through your AI tool's hook system, so capture and orient happen automatically. It works with Claude Code, Codex, and Grok Build today. The memory files are plain Markdown any assistant can read.
What is Celeborn-in-Chrome?
An optional browser extension that pairs a Chrome profile with your local Celeborn, so your coding agent can drive a real browser when a task calls for one — checking a live page, filling a form, reading a console. The guided installer offers it as an optional step, and you can grab it any time from celeborncode.ai/download/chrome (you click the extension icon once to pair the profile).
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. Install on each machine and sign in with the same account; `celeborn sync` carries a project's memory between them — it travels through your account, never through git. Your .context/ stays as plain files on each machine's disk.
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?
You don't have to do anything — that's the default and the only mode. The entire .context/ memory (notes, prompts, journal, everything) is always gitignored and never committed, in every setup, so nothing personal can end up in a shared or public repo.

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 Celeborn send off my machine?
By default, almost nothing. Your code and .context/ memory live and stay on your disk. The one routine network call is a tiny subscription check tied to your account — a signed receipt that carries no code and no memory, cached locally so it also works offline. Sync and the hosted board transmit only what you deliberately sync. Before capture or upload, Celeborn replaces text matching its configured credential detectors. That pattern matching does not identify arbitrary passwords, unknown token formats, PII/customer data, sensitive paths, or commit/test metadata, and project configuration can replace the defaults. Do not paste sensitive data into prompts or support chat; run `celeborn doctor` for the available pattern-based scan. Full boundary: celeborncode.ai/secret-redaction.
Will you email me? What emails does Celeborn send?
Only standard transactional email — the messages an account actually needs: confirming your email address at sign-up, receipts and billing notices, team and board-share invites, and the occasional important account or security notice. When someone adds you to their team or shares a board with you, we email you that invite — administrative business only. That's the whole list. We never send marketing blasts, newsletters, or spam, and we don't sell or share your address. Transactional mail comes from no-reply@thot.ai (thot.ai publishes Celeborn Code) and isn't monitored for replies — to reach a human, use the support chat.

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 engine runs entirely on your machine, and your .context/ memory stays local — the only routine network call is a small subscription check that carries no code and no memory. Nothing about your code leaves your computer unless you deliberately turn on sync or explicitly share something with our support team to get help.
If I turn on the paid Trusted Flow mix, where does my code go?
The local engine still keeps your code and .context/ memory on your machine. When you run the paid Trusted Flow mix, it sends your prompts and the code context a card needs through the AI Gateway to model providers. Which providers we may route to, and where they can be located, is spelled out in the User Agreement — read it before you subscribe so you can judge the fit. Prefer to keep it off? The local engine and your own coding agent never route to it. Read the terms
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 unless you turn on sync they never leave your machine 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 engine is fully local (your code and memory never leave your machines — the only routine call is a signed subscription check carrying neither), 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?
Four monthly plans. Easy is $20 and includes the full local product, DeepSeek V4 Flash, and an $8 monthly model budget with no usage overage. Claude Code and Codex are optional connected engines. Junior is $59, Senior $119, and Chief $249. Those plans add Trusted Flow, cloud features, and larger model budgets. Your first month is charged when you start, you can change plans in the billing portal, and cancellation is one click. See the membership tiers
Why is there no free tier?
Because we intend to still exist next year. Most of Celeborn's value runs on your machine, but the product, updates, and support still require ongoing work. Easy keeps the entry price at $20/month when you bring your own Claude Code or Codex subscription. The membership bills monthly from the day you start, and you cancel in one click. Before paying, you can watch the seven-card demo with no account and no card.
When am I first charged?
The day you start. Checkout charges the displayed monthly plan price: $20 for Easy or the displayed Hosted Plan price. There is no live trial or delayed charge in the current funnel. The plan renews monthly until you cancel. Cancel and paid Celeborn features stop at the end of the paid period, but your .context/ files remain untouched on your disk.
What is Trusted Flow?
Trusted Flow is a membership feature: a model blend that routes each card of work to whichever AI model gives the best result for the money — blending Claude (Opus, Fable), ChatGPT, GLM, and other high-value models. Hard cards still go to frontier models: the promise is frontier quality for less — not a claim that the blend matches Claude on every card. We won't publish a parity claim until our own acceptance data supports one. It runs on metered billing (a budgeted gateway key, enforced server-side), so you only pay for what the blend actually spends. You don't have to give anything up: keep your existing AI subscriptions and use Trusted Flow only where it saves you money. Rolling out now — the billing page shows your live spend and a savings receipt against the all-Claude cost. How Trusted Flow routes and what it logs
How big is the engine budget, and what's this about peak hours?
Every plan has a hard monthly model cap with no usage overage. Easy includes $8 for DeepSeek V4 Flash. Junior, Senior, and Chief include the larger dollar figure shown on each plan card, roughly 40–45% of its price, for Trusted Flow. Each budget refills every billing period and does not roll over. Optional Claude Code or Codex sessions use that provider's subscription instead of the Easy budget. Read the terms
How does billing work?
Checkout is on celeborncode.ai/start → Stripe. Your first month is charged when you start, then the plan renews monthly until you cancel. Celeborn Code, published by Thot Technologies LLC, is the seller; Stripe processes cards, wallets, tax, receipts, and invoices. Celeborn never sees or stores your card number. The billing page opens Stripe's portal for invoices, payment methods, plan changes, and cancellation. Easy's separate Claude Code or Codex subscription remains between you and that provider.
I got a receipt or billing email from Stripe or Link — is that really you?
It can be. Stripe processes Celeborn payments and sends receipts, invoices, refunds, renewal notices, and failed-payment notices. Link may appear if you use its saved-payment service. Check that the message names the Celeborn Code purchase and matches the amount and date in your billing portal. Celeborn also sends account mail — sign-up verification, team and board-share invites, and security notices — from no-reply@thot.ai. If anything looks wrong, do not follow its links; open the support chat from celeborncode.ai and we will compare it with the actual charge.
How do I cancel?
From your billing page: “Manage billing” opens your Stripe portal, and cancellation is one click — no chat with a retention script, no email required. You keep full access through the end of the month you've already paid for, and your local .context/ memory is yours forever either way.
What's your refund policy?
Cancel anytime in one click and you keep access through the end of the month you've already paid for — there's no lock-in and no long commitment. If billing went wrong — a double charge, a renewal you meant to cancel, a paid feature that didn't work for you — open the support chat and tell us; genuine billing mistakes are refunded promptly and without a fight. And before you pay at all, the 7-card demo lets you watch the whole thing work with no account and no card.
How do I reach support or a human about billing?
Use the Support pill on your board or the chat on this site. It is Celeborn's support channel for billing, refunds, and plan questions. Payment mail — receipts, invoices, and renewal or failed-payment notices — comes through Stripe and may mention Link when that payment service is used. If a message looks wrong, avoid its links and open the support chat directly from celeborncode.ai so we can compare it with the actual charge.
We're comparing tools — why pick Celeborn?
Three things people consistently value: you can watch the whole thing work before paying — the 7-card demo replays seven cards being built end to end, no account and no card; the memory is open Markdown on your machine, so there's zero lock-in 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 one engineer on Easy and a real project; DeepSeek V4 Flash works immediately under the $8 monthly hard cap. Optionally connect Claude Code or Codex, then compare the engines on real cards. Upgrade to Junior when you want Trusted Flow, Guard, a larger budget, or cloud features. The seven-card demo shows the workflow first with no account and no card.
Can we buy through procurement, get invoices, or sign our own terms?
Yes — ask in the support chat about procurement invoicing or custom contractual terms. Self-serve Easy, Junior, Senior, and Chief plans run on Stripe Checkout from celeborncode.ai/start.
If I cancel, do I lose my project memory?
No. Your local .context/ memory is plain files on your own machine and completely unaffected — you keep it forever, readable by anything. When the subscription ends the Celeborn machinery stops (the CLI, board, and sync), but nothing is deleted and nothing is locked away: your memory is yours, the machinery is ours. You also keep full access 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 starting one engineer on a real project lets your team measure it directly, which is more convincing than anything we could quote.

What Celeborn is not

Is Celeborn open source?
Celeborn's installer is source-available under the Business Source License (BUSL 1.1) — public on GitHub to read and audit — while the app itself ships as a compiled binary; neither is an OSI open-source license. Your data stays in open formats (plain Markdown) precisely so you're never locked in.
What's source and what's binary? What exactly can I read?
Since v0.3.0 the app ships as a per-OS compiled binary (macOS, Linux, Windows), and what you read is the installer: the BUSL 1.1 source on GitHub and PyPI that downloads the binary and verifies its sha256 checksum before anything runs. Homebrew, Scoop, and winget install the same verified binary directly. Same subscription either way, and your data never moves into a closed format — the .context/ memory is plain Markdown regardless of how the app is packaged. Versions published as full BUSL source (up to 0.2.1) stay that way forever, each converting to Apache-2.0 on its Change Date.
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 runs offline (your membership check is a small signed receipt cached locally) and nothing leaves the machine. If you mean self-hosting the cloud layer (sync and the hosted board) inside your network, start that conversation in the support chat.