Meet OpenAcme: an AI workforce you run yourself

Most AI tools give you a chat box. You type, it answers, you type again, and the second you close the tab it's all gone. The model has no name, no job, no memory of the correction you made last week, and no way to lift a finger while you're not watching it.

OpenAcme is built around a different idea. Instead of one assistant you talk to, you run a workforce: a roster of agents that each have a name, a job, their own tools and memory, and the ability to take work and actually finish it without you sitting there. You're not a user typing into a box. You're the person the work reports to.

A roster, not a thread

Every agent in OpenAcme is a coworker you can describe in a sentence. Each one has a name, so you can address it and so its coworkers can. It has a role, written the way you'd brief a teammate ("researches competitors and writes briefs," "keeps our docs in sync with the code"). And it has a persona, the private instruction that shapes how it actually behaves. On top of that, every agent carries its own model, tools, skills, memory, and workspace, fully separate from everyone else on the roster.

An agent's detail page showing its role, persona, tools, and model — An agent's page. The role at the top is what coworkers read; the persona below it is private instruction only that agent sees.

That separation is the whole point. An analyst and an engineer shouldn't share the same browser logins, or the same memory, or even the same model, so they don't. You add an agent, retire one, or swap a model for a single role without touching anyone else. The roster grows the way a real team does, one hire at a time.

Hand off work and walk away

Talking to an agent is fine. The real shift is that you can hand one a task and leave. You write it the way you'd brief a coworker, a title and a short note on what "done" looks like, and it lands on a shared board where a dispatcher wakes the right agent to pick it up, usually within the minute.

The task board showing open, in-progress, and done tasks across agents — The board. Work moves across it on its own as agents claim tasks and finish them.

And tasks aren't just one-shot prompts. They can recur, so a finished daily task quietly re-opens itself for tomorrow. They can depend on each other, so a dependent task waits until the thing it needs is done. And they report back as comments, with the full event log of what the agent actually did to get there. So you can assign three things on your way out and read the answers when you're back, instead of babysitting a prompt and copy-pasting between tabs.

A finished task with the agent's written result posted back as a comment — A result comes back as a comment on the task, not as a message you have to be online to catch.

Everything a coworker needs

A chat window with a couple of plugins bolted on isn't a coworker. An agent that gets real work done needs an actual working setup, and each one has it:

Memory. Corrections, preferences, and context get written to a Markdown file the agent keeps for itself, and carried into every future session. Tell it once that you hate em dashes and it still knows next month.
Skills. Teachable abilities, written in Markdown. Install them from GitHub or a marketplace, or write your own and drop them in.
A browser. Each agent gets its own browser session with its own logins and cookies, so one agent signing into an account never leaks that session to another.
Any model. Mix providers across the roster. A frontier model for the hard roles, something cheap or local for the rest.
MCP. Wire up any Model Context Protocol server and its tools show up for the agents you choose, namespaced per agent or shared across the workforce.

The Skills page showing installed skills and available sources — Skills are Markdown. Install from a source or author your own, and the agents you pick can use them.

When work spans more than one person, you don't have to micro-route it. Group agents into a team, send the team a task, and the team's manager triages it: claims it, reassigns it, or splits it into smaller pieces for the others.

A team page showing members and the assigned manager — Send work to a team instead of a person. The manager decides who actually does it.

It runs where you work

OpenAcme is self-hosted. There's no OpenAcme cloud sitting between you and your data. Your prompts and files go to the model provider you picked and nowhere else.

On your laptop. Install, sign in, done. Everything lives in ~/.openacme, plain Markdown and SQLite you can open, read, grep, and back up.
On a shared server. Run openacme start --expose and your whole team works with the same workforce, behind one URL, with real accounts.

The web console and the CLI are the same product. Anything you can do in the browser you can do from the terminal, including openacme chat, which runs an agent in-process with no server at all.

Get started

npm install -g @openacme/cli && openacme setup

That walks you through connecting a provider, whether that's a Claude or ChatGPT subscription or a plain API key, and then you're ready to hire your first agent. The Quickstart takes it from there.

This is the first of these notes. We'll use the blog for design notes and the things we learn building this, and the changelog for what ships. Welcome aboard.