You've been the whole company long enough.

ADI runs agents on your own machine — you define each one, and it holds your tools, your data and the memory of the work between conversations. Close the tab and it still knows what it knew. Hand off the roles you can't afford to hire for.

Download ADImacOS · Linux · WindowsRead the source

The ADI control panel: a rail of twelve conversations across six agents, an open conversation in which one agent lists the seven open tasks across the projects and names which agent to hand each one to, and a panel beside it accounting for the run — model, twenty tool calls, tokens, seconds and spend.

One agent reading the task tree and naming which of the others should pick up each item. Every run is accounted for on the right: model, tool calls, tokens, spend.

The month asks for 843 hours. It has 730.5.

Sleep, the day job, the commute, the house, the people in it — American Time Use Survey, 2025 — plus the hours founders say they put into their own thing.

Sleep and the job don't move. Neither do the people at home. But one part of that column is work you'd have hired for: the support email, the outreach, the follow-ups nobody sent. You do it because hiring starts at a salary. The overdraft comes out of the right-hand column.

730.5 hours in the month

843 hours asked of it

What you mustWhat you want

ATUS 2025 + self-reported founder hours · profile: employed, building at night

Hand off the roles, not the tasks.

An agent in ADI isn't a chat window. It's a definition you keep: a model, a prompt, the exact tools it may run, the secrets it may use, and a memory of its own.

You don't build any of that by hand, and you don't learn the platform to get it. ADI comes with an agent whose job is ADI: you ask, and it writes the tool, files the project, puts the service up.

# agents/support-agent.toml — the whole of it
backend = "harness:claude-sdk"
project = "acme"
# refund-lookup: it wrote this one itself, the second time it needed it
bin_tools = ["inbox-read", "inbox-reply", "refund-lookup"]
memory = true

[[secrets]]
name = "HELP_SCOUT_TOKEN"

[arguments]
model = "opus"
system_prompt = """
You answer support mail for acme. Refund anything under $50 without asking.
"""

It keeps its own memory
What this run worked out, the next one starts from. Searched by meaning, not keywords.
It makes its own tools
The second time an agent needs the same thing, it writes itself a CLI for it — or you ask for one. Each gets the tools you ticked, not the ones you didn't.
It doesn't stop when you close the tab
Triggers fire on events. Tasks outlive the run that made them.

Then close the laptop.

The same store runs headless on a Linux box, and keeps running after you log out. No open port, no ssh — it dials out to pair.

Then it doesn't need you. A service stays up; a webhook or an event starts an agent with the prompt you wrote for exactly that alert. What it works out is in the task tree when you get back.

Every machine you pair reaches the others, authorised by key, exposing only the ports you named. Your iPhone too — any dashboard, on any of them. That app is in review and not downloadable yet.

One store. One control panel.

Everything ADI runs lives in one directory, browsable and editable at app.adi on your own machine — a name your own DNS answers, which installs as an app if you'd rather it were one.

One project's Services panel: an api service on api.beacon.adi running from a script at 24.3 MB, and a db service declared as a postgres container, stopped, with a Start button.

Projects: with the services, secrets and database that belong to them.
Agents: a model, a prompt, scoped tools, a memory of their own.
Tools: small CLIs an agent writes when it needs one, or when you ask.
Knowledge: notes searched by meaning.
Code index: your source, by meaning, name or path.
Tasks: one tree everything writes to.
Triggers: a webhook, an event, or a process, running your code.
Services: script or container, supervised, on its own name.adi.
Dashboards: loose .ts files that hot-reload as you edit.
Secrets: encrypted at rest, injected into a run, never shown by a listing.
Database: one SQLite store all of them share.
Mesh: pair another machine and grant it exactly what it may reach.

The panel's own file browser with projects/api/.adi/hive.yaml open and editable — the service, its host, its runner and the port it leases, in plain YAML.

Part of your machine, not a tab in someone's cloud.

There is no account to create. Your projects, your database, your secrets and your agents' memory sit in one directory on your own disk, under your own backups. Pull the network and the store is still yours.

You bring your own model account — that call goes to whichever provider you already pay for. A few other things reach the network, and they're named right here. One of them is ours: a fixed list of usage events, with no prompt, file or secret in any of them, and one command to switch them off. This website counts page views and a few clicks too, and the privacy page says what it keeps.

What uses the network

Your model provider — inference goes to the account you already pay for.
The update check — one static file from GitHub Releases, at login and every six hours; the comparison happens here. adi-mono update disable stops it, update/config.toml repoints it.
The mesh relay, if you pair two machines over the internet — they meet at a relay, and between two home connections it often carries the connection itself, not just the introduction. Left alone that is iroh's public relays, run by n0; name your own in mesh.toml.
Signing in with Google or GitHub — a router we run trades the sign-in for your token and hands it into your own secrets store, and is called again whenever that token is refreshed. No database, no session, no ADI account.
The embedding model — the weights download once, from Hugging Face, then run here.
Usage events, from the version after 1.30.0 — a fixed list (first start, setup finished, runs in your first week, one a day while it runs) sent to our own collector at relay.withadi.dev with a random install id; never your prompts, files or secrets. They are on unless you switch them off: adi-mono analytics disable stops them, and the privacy page lists what each one carries.

What it isn't.

ADI is early. It's built and used every day by one person, and that person wrote it. There are no logos on this page and no case studies, because there is nothing yet that would be true.

It doesn't ship your product while you sleep. There's no seat count, no licence key, and nothing that asks permission to run on hardware you own. The connections it does make are named further up this page, and the ones you didn't ask for are yours to switch off or point somewhere else.

Free for you. Licensed past $1M or ten people.

ADI is free for you. Using it for yourself — your own projects, learning, anything that isn't commercial — is free for anyone, with no revenue or headcount test. Using it for a business is free too, as long as that business is under $1M a year and under ten people: the whole team, not a trial.

Past those numbers, a company needs a commercial licence from us. It is $3,000 a year per instance, and the licence names one place to ask.

The source is public: read it, build it, change it for your own use. You can't redistribute it without written permission, and you can't use it to build a competitor to ADI. It makes no claim on what you make with it.

The licence is proprietary and source-available, and it is short. Read it before you take any of this on trust. Read the licence

Get the hours back.

Runs on your machine. Free under $1M and ten people. Read the source

Download ADI.

It runs on your own machine, so this is the whole of it: one file, and no account to create before or after.

Every build, its checksums and its release notes are on the releases page. ADI checks for updates itself once it's installed — and adi-mono update disable stops that.