you control your datacompliance built inbuilt for collaboration
Pro-grade AI coding. Your data never leaves your control.
AdultCoder turns open-weight models on your own hardware into pro-grade coding agents, and works with Claude and other hosted models through your own API keys when you choose. Built for teams that ship products under real privacy and compliance rules.
Proprietary. No telemetry. Built for teams that answer to auditors.
ac — ~/product
# your hardware for everyday work$ ac model set default ollama/qwen3.8:27b-mlx# your own key for the hardest turns$ ac model set quality anthropic/claude-opus-5-5# nothing changes until you approve$ ac plan "add SSO to the admin console"# hand over the long job, walk away$ ac --unattended "move billing to Postgres"/plan /implement /budget /unattended
open-weight, pro-gradekeys out of reachaudit-readyno telemetry
auto mode, with brakes
No approval for ordinary work. It still stops before:
deleting what it did not create
touching what is important
reaching outside the workspace
! your data, your control! pro-grade on open-weight models! your own API keys! compliance built in! a budget on every task! every command sandboxed! proprietary Rust engine! built for team collaboration! context that stays with the team! no telemetry! your data, your control! pro-grade on open-weight models! your own API keys! compliance built in! a budget on every task! every command sandboxed! proprietary Rust engine! built for team collaboration! context that stays with the team! no telemetry
why teams switch
AI coding breaks in five places once a team depends on it.
We lived through each of these in enterprise teams, and built AdultCoder so each one has an answer.
01 · data
Your code leaves the building.
Most AI coding tools send your code and prompts to someone else's cloud, under someone else's retention policy.
AdultCoderRuns open-weight models on your own hardware. A hosted model is used only when you name it, with your own key, straight to that vendor. No telemetry.
02 · compliance
Compliance asks questions your AI tool can't answer.
Which model saw which file? Who approved that change? Where did the prompt go?
AdultCoderKeeps an audit log of every model conversation, hash-chained and ready to export. Approvals stay with the project, and no project file can loosen the machine's policy.
03 · secrets
Secrets end up in prompts.
An agent reads your environment and hands whatever it finds to a model.
AdultCoderKeeps keys in the system Keychain, where its commands can't reach them. A known key that turns up in output is redacted, and every command runs in a sandbox with a network allowlist.
in development Optional masking of secrets and personal data in everything sent to a hosted model, with the real values put back only on your machine.
04 · team context
Your team's AI context walks out with the seat.
Months of chats, memories and rules live in each person's account. Change the subscription or lose a teammate, and that context goes with them.
AdultCoderKeeps sessions and project memory with the project, on your machines, whichever model you use. Memory is a plain file in your repository, and sessions sync across the team, signed and encrypted.
05 · understanding
After months of vibe coding, nobody knows how it works, or whether it does.
The code is there. The reasons behind it, and the proof that it works, are not.
AdultCoderLeaves a trail for every change: the plan someone approved, the session that wrote it (replayable step by step), the commit marked as AI-made, and the checks it actually ran.
why we built it
We wanted the speed of AI coding without giving up our code, our keys or our team's knowledge.
The tools we had made us choose. So we built one that doesn't: pro-grade results on models you run yourself, hosted models only on your terms, and a record your team, your security people and your auditors can all read.
control, not promises
Privacy you can verify, not just read about.
Every number here is a setting or a boundary in the product, not a policy page.
0
telemetry
AdultCoder reports nothing about you, your code or your use of it.
0
API keys the agent can read
Its commands run without them, and a key that turns up in output is redacted.
0
project files that can loosen your policy
The sandbox, the audit log and unattended mode are the machine's to set. A cloned repository can only make the sandbox stricter.
4
hosted providers, none by default
Anthropic, OpenAI, DeepSeek and Qwen, each only when a model names it, with your key.
one shared record
The same evidence for engineering, security and leadership.
What the agent did is written down where everyone who carries the risk can read it.
A
Plans, approved
Nothing changes until someone approves the plan, and the plan stays with the session.
B
An audit log of every model conversation
Hash-chained and owner-only, exported with a manifest for your audit server.
C
Sessions you can replay
ac replay runs a stored session again, or walks through it step by step.
D
AI commits, marked
The commits AdultCoder makes carry a co-author line, so history shows which changes it wrote.
open-weight, pro-grade
The model is half the result. The tooling is the other half.
AdultCoder gets professional work out of open-weight models you run yourself, and more out of Claude when you bring it in. You keep the hardware, the model and the data.
Plans before it touches anything
Large tasks start with a plan, and nothing changes until the plan is approved.
Checks its own work
It opens what it built in a real browser, measures it, runs your tests, and keeps fixing while a measured problem remains.
Finishes long work
Long conversations are compacted without losing the task. Left alone, it waits out outages and stops at the limits you set.
Spends what you allow
Open-weight models on your hardware cost no tokens. Hosted turns run under turn and session budgets, with the spend on screen.
budgets, then outcomes
Set the budget. Get the finished work.
Give a task a budget in dollars, and in minutes if you like. AdultCoder works until the job is done, checking its own work as it goes, and stops between steps when the money or the time runs out, saying what it spent. Need more? Raise the budget and carry on from where it stopped.
1
Every cent counted
Spend is measured as it happens, at list prices, with prompt caching, compaction and web searches included. Helpers, parallel workers and generated media draw on the same budget.
2
Progress, not loops
A long task keeps going while it makes new progress, and stops when it is done, stuck, or out of budget. A run going in circles ends instead of burning your money.
3
A clean stop, then a resume
At the limit it stops between steps and says what it spent. ac resume picks the work up again.
4
Free on your own hardware
Open-weight models on your machines cost nothing, so only the time limit applies to them. Mix them with hosted models in one session, and pay only for the hosted turns.
ac — ~/billing
# one task: a budget in dollars and minutes$ ac chat --max-cost 5 --max-minutes 45"move billing to Postgres"# a whole session, its spend on screen$ ac --max-session-cost 8$3.20 of $8.00# at the limit: a clean stop, and the bill the session spent $8.00 of its $8.00 budget/budget +5
spend you can plan
A budget per task (--max-cost), per session (/budget), or for every turn in the machine's settings, which a cloned repository can't loosen.
built in Rust, native everywhere
A native engine, not a web app in disguise.
AdultCoder's engine is our own, built in-house and closed source, written in Rust and compiled to one native binary: no Electron, no browser engine and no JavaScript runtime inside it. Its apps are native too: Swift on the Mac, and native on Windows next. Large repositories and long sessions stay quick and light.
proprietary enginewritten in Rustnative appslight on memory
measured, not claimed
0.01 s
to start
The engine is ready in a hundredth of a second.
56 MB
peak memory for a turn
A full turn in a 200,000-line Rust repository.
0
browser engines inside
No web view and no JavaScript runtime in the engine.
1
binary, both kinds of Mac
Apple silicon and Intel run the same native build; Windows is next.
built for collaboration
AI context that belongs to the team, not to a seat.
Built with team collaboration in mind from the start: one memory, shared sessions and the same rules for everyone on the project. When a subscription changes or a teammate moves on, the work and the context behind it stay.
A
Memory in your repository
A plain Markdown file that every model reads in every chat. Review it, commit it, keep it.
B
Sessions the team can share
Export a session or sync a team folder, signed and encrypted. A history that diverged is imported as a copy, never written over.
C
Any session, on any model
Pick up a teammate's session on another model. Changing vendors keeps the history.
D
Parallel work without collisions
Workers change code in their own git worktrees, and a session can run on its own branch.
E
One policy for every project
The machine's sandbox, audit log and spending limits apply everywhere. A cloned repository can't loosen them.
ac — ~/product
# memory every model reads, in the repo$ ac memory append "POSTs carry idempotency keys"# sessions shared through a team folder$ ac sessions --sync-dir /team/ac-sync --sync-namespace billing# its own branch, its own worktree$ ac chat --worktree sso# a teammate's session, another model$ ac resume 4588382a --model quality
keys for shared sessions
Sessions are signed and encrypted with keys you generate, keep in the Keychain, and rotate without losing older bundles.
where your data goes
You decide where every byte goes.
By default, prompts and code go only to models on your machine or your network. Crossing the line is something you write down, model by model, with your own key.
your machine
Everything, by default.
1ac and its shell
2Open-weight models, through Ollama
3The agent's commands, in a sandbox
4Your API keys, in the Keychain
5Sessions, memory and the audit log
keys stay homeonly when named
your network
Models on your own servers.
Ollama, llama.cpp, vLLM or LM Studio on your other machines, with history kept inside each model's context window. Your hosted providers' keys are never sent there.
outside, only with your keys
Anthropic, OpenAI, DeepSeek, Qwen.
Used only when a model names one, and its key goes only to that vendor's own API, over https. Web search and MCP tools you turn on make their own requests.
the agent, today
Everything a long, private task needs.
Version 0.2, as it stands: a terminal shell and a Mac app, open-weight and hosted models, long autonomous work, and the guardrails that make it safe to leave running.
A shell and a Mac app
The conversation lives in your terminal's own scrollback. The menu bar app sets up keys, model servers and defaults.
Plan, then build
ac plan changes nothing until you approve; /implement runs the approved plan. Large prompts plan first on their own.
Claude, properly
Effort from low to max, ultrathink by the word, and a prompt cache that holds from turn to turn.
Long work, on its own
Auto mode needs no approval for ordinary work. Unattended, it keeps trying through an outage and stops at your time and money limits.
Brakes that hold
Deleting what it did not create, touching what is important, or reaching outside the workspace still stops for you.
Helpers and workers
Read-only helpers run side by side; workers change code in their own git worktrees, so nothing collides.
Sandboxed commands
Every command the agent runs is sandboxed by default, with a network allowlist.
Keys out of reach
Keys live in the Keychain and go only to their vendor's own API. The agent's commands never see them.
A browser review that measures
It opens the page it built, scrolls it, measures overflow and the phone menu, and keeps fixing while a measured problem remains.
Memory that learns
Lessons, examples and offline documentation stay on your machine and come into later turns when they are relevant.
Sessions that travel
Sessions move with the project. Bundles are signed, encrypted and redactable, and every session can be replayed.
Any MCP server
Any MCP server's tools join the agent's own, and none is on until you add it.
built in, beyond code
Images, voice and video, from the same agent.
Coding comes first. When a product needs more, AdultCoder makes it in the same session, and says what each piece costs before anything is spent. Images and video come from hosted media models with your own key; voices can stay on your own network.
Images and icons
Illustrations, sprites with transparent backgrounds, pictures with legible words, and app icons for every platform, side by side to choose from.
Voice and sound
A script read aloud with captions, music and sound effects. Voices can run on a voice server on your own network, in up to 31 languages.
Video and films
Short clips from a prompt or a still, and finished films in every format with subtitles, chapters, a thumbnail and shorts, rendered on your machine.
Spending you set
Each request's price is said first, and media has its own limits per session that a project can only lower.
the ecosystem
One engine. One policy. Every surface.
We are building a family of tools for collaborative, privacy-focused teams, all on the same engine and the same controls, so your policies and your context follow the team from the terminal to the IDE.
And the engine under all of them is ours: proprietary technology, built in-house in Rust, with native apps around it. No Electron, no web views, and no one else's agent underneath.
proprietarybuilt in Rustnative on every platform
ac, the agent
beta soon
The coding agent and its framework, in your terminal: the engine every other surface runs on.
AdultCoder for Mac
beta soon
A menu bar app for keys, model servers, defaults and policies, without the command line.
AdultCoder Desktop
in development
A desktop app for the whole team, on the same engine and the same controls.
AdultCoder IDE
in development
An editor built around the agent, for teams who live in their code.
Windows
in development
The ac command and a tray app for Windows, the way the Mac has them.
A private model server
in development
Open-weight models served from your own hardware to your team, behind a key.
for enterprises
AI coding should make your team faster without making your data someone else's.
Controls your security team can inspect, rather than take on trust: every command in a sandbox with a network allowlist, API keys the agent cannot read, permissions kept in the project that granted them, and an audit log of every model conversation.
privacy firstcompliance built inno telemetry
for teams
Shared context, parallel work.
Project memory in the repository, read by every model
Sessions shared across machines, signed and encrypted
Workers in their own worktrees, so nothing collides
for professional developers
Your machine, your model, your rules.
An open-weight model on your own hardware by default
Claude for the hard turns, with your own key in your Keychain
Keys, model servers and the default model set up from the menu bar
faq
What teams ask before they let an agent near their code.
Short answers, each one something you can check in the product.
Not by default. The built-in default model runs on your own machine, and models on your network work the same way. A hosted model is used only when you name it, with your key, directly to that vendor. Web search and MCP tools reach out only when you turn them on.
Yes: Anthropic, OpenAI, DeepSeek and Qwen, each with your own key, kept in the system Keychain. The agent's commands never see it, and AdultCoder asks before work moves to another provider's model.
Your provider keys never reach a model today, and a known key that turns up in output is redacted. Optional masking is in development: secrets, emails, phone numbers, card numbers and ID numbers in anything sent to a hosted model become placeholders, and the real values are put back only on your machine, in what the agent writes.
With the right tooling, yes. AdultCoder plans first, checks its own work in a real browser and with your tests, and keeps going until the measured checks pass. Bring in Claude for the hardest turns when you want to.
A native engine starts in a hundredth of a second and works in tens of megabytes, so it stays quick on large repositories and long sessions. There is no browser engine or JavaScript runtime inside it, and its apps are native too.
With it on, every conversation with a model API: the model, its settings, every message sent and every reply, with keys taken out. Files are owner-only and hash-chained, and they export with a manifest of their hashes. AdultCoder writes the log and never reads it.
No. AdultCoder reports nothing about you, your code or your use of it.
It stays. Sessions and project memory live with the project on your machines. Any session can continue on another model, and the memory is a plain file that every model reads.
With a model on your machine or your network, yes, offline documentation included. Web search needs the internet, and runs only when you turn it on.
Yes. Give a task a budget in dollars and minutes, or a whole session one in dollars. The spend is on screen as it works; at the limit it stops between steps and says what it spent, and you can raise the budget and carry on. Models on your own hardware cost nothing, so only the time limit applies to them.
No, it is proprietary. What you can inspect is what it does: the audit log, the sessions and the permissions are all yours.
private walkthrough
If your data has to stay yours, we should talk.
Early access opens in waves, and enterprises and technology companies come first. We will show the engine, the controls and the audit trail on the kind of project your team builds.