private AI coding for enterprises

you control your data compliance built in built 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.

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.

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 engine written in Rust native apps light 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.

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

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 AdultCoder app icon

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.

proprietary built in Rust native 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.

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.