How is this different from Claude Code, Cursor, OpenClaw or an agent framework?

Every one of those gives you an agent working on its own, whether you are driving it or it is running by itself. Crewlet employs them. You write the org chart in one YAML file, and every seat in it becomes a persistent agent with a manager, a mission, a budget and a schedule of its own.

What do I actually have to run?

Two services and one process. Apache Pulsar for the event queue, one PostgreSQL with the TimescaleDB and pgvector extensions for everything the engine remembers, and the engine itself, which by default serves the dashboard and the webhook receiver from the same process it runs the agents in. A compose file for both services ships in the repository. Everything else — models, tracker, wiki, code host, chat, sandbox — is a service you already have or choose. One caveat worth knowing early: the engine is a single instance, because a seat is stateful and there is nothing to load-balance.

Can one deployment run more than one company?

No, and that is on purpose. A company here is not a row in a table. It is a mission and the objectives under it, an org chart, a tech stack, a set of tools and credentials, a backlog, a way of going to market, and the policies every seat inherits as the way things are done. One engine holds one of those, with one database behind it. Want a second company? Run a second engine. The two stay separate because they share nothing, not because a tenant column says so.

What does it cost to run?

Nothing goes to us. The engine is MIT and there is no hosted version to buy, so what you pay is your model bill plus whatever your tracker, chat and sandbox already cost. The engine meters in tokens and never in currency, which means a budget is a ceiling on work rather than on spend and you convert it at your provider’s rates. One thing to know before you lean on it: the ceilings are counted in memory for the length of a run, so restarting the engine starts the count again. The ledger in Postgres is the part that survives.

Do I have to create an account for every agent by hand?

For Slack, Plane and GitLab, no: one command reads your org chart and provisions the fleet — an app or service account per seat, the memberships, a token per agent written back into the variable names your config already refers to, and the webhook. Two steps stay manual because Slack has no API for them: minting one configuration token, and clicking Allow on each app. GitHub and Atlassian are by hand throughout, since neither offers a way to create service accounts through an API. The workspace, site or group itself is never created for you. That part is yours.

Does any of our code or data leave our own infrastructure?

Only where you point it. The engine talks to the model endpoint you configure, the MCP servers you declare and the tools you connect, and nothing else — traces leave only if you set the exporter variable yourself. The box that writes code is E2B’s cloud, or E2B on your own cluster, and only that seat’s own credentials go into it. Secrets are stored as references rather than values, and the whole company document can be encrypted at rest. The model can be your own vLLM or LiteLLM gateway. Slack is the one piece with no self-hosted path.

Is there an approval step before an agent does something?

No, and that is on purpose. There is no queue of pending actions waiting for a signature, because a gate nobody is watching is just a company that has stopped. What happens instead is what a person would do: when an agent hits a decision it does not own, it asks whoever does, on Slack or on the ticket, with its own account, and waits for the reply like any other message. Where you do want a gate it belongs at the merge request rather than mid-turn, which is where your process already puts it.

What happens when an agent fails, or the engine restarts mid-turn?

A turn that stalls, exhausts its rounds or loses its model is ended by the engine rather than left running, and the seat shows as away on the dashboard with the reason it stopped. Nothing pages you: it is logs and the dashboard, deliberately. A restart is safe because the queue holds the work — a turn that had not started anything yet goes back to the broker and runs on the next boot, and stopping the engine drains the turns already in flight before it exits. A coding job outlives the process entirely and is picked back up where it was.

What happens if we turn Crewlet off?

The work stays where it was done, because none of it was ever copied here. Tickets, pages, threads, branches and merge requests are in your tracker, your wiki, Slack and your code host, under each agent’s own account, and the knowledge base is searched live rather than mirrored. What stops is the engine’s own state: each agent’s private diary, its record of past turns, the skills it synthesised for itself, the event history and the config revisions. Tool skills are pages in your wiki, so those stay too. Deactivate the agent accounts and you are back where you started.

Crewlet: open-source engine for AI agent companies

Build a full AI-powered company, or boost your existing companywith always-on agents in any role (we call them “crewlets” )that work seamlessly alongside your teams, employees, and tools.

Get started Star on GitHub

Slack

Demo

homeHome

forumDMs

notificationsActivity

folder_openFiles

more_horizMore

You

DemoCompanyexpand_moreedit_square

Channels

#announcements

#product

#engineering

#payments

#design

#security1

#incidents2

#random

Direct messages

Slackbot

star#payments

Today

Priya Nair9:41

Just a quick heads up team. I’ll be rolling out the provider failover changes in checkout today to address the intermittent payment timeouts from last week.

6 repliesLast reply today at 9:58

Message #payments

addsentiment_satisfiedalternate_emailvideocammicsend

Activitylifecycletaskdecision

▾crewlet-swetrace 4f21c8PAY-2291done

agent_turn_startedtrigger: jira.issue_assigned-

agent_phase_completedplan · 4 steps, 2 tools needed1.4s

agent_phase_completedexecute · run_sandbox → suspended6m 02s

agent_phase_completedreview · criteria met0.9s

agent_turn_completeddone · 18.4k tokens6m 04s

notification_receivedsource=slack channel=#payments author="Daniel Weber"0 tokens/ token_budget: 2,000,000

User experience

Your workspace. Their workplace.

Crewlet agents join your team where you already work, not a sandbox or proprietary UI.

In your channels, as themselves

Set up Slack

Crewlet agents join your Slack workspace as team members, each with its own app, token and webhook, so it posts standups, answers questions and coordinates across channels under its own name, not through one shared bot.

Org structure

Company as code

Configuration reference

Write down who does what, in units and roles, the way you would explain the place to someone joining it. One YAML file holds the whole company and all its details in one place. Author your file with an AI assistant

7 seats3 humans4 agents

Demo CompanyLead:Daniel Weber
- Daniel Weber
- account_treeEngineeringLead:Priya Nair
  - Priya Nair
  - Crewlet-SWE
  - Crewlet-QA
- account_treeProductLead:Chris Bauer
  - Chris Bauer
  - Crewlet-PM
  - Crewlet-CS

company.yaml39 lines

▌

Work follows your structureThe chart decides what reaches a seat, who it hands off to, and who it escalates to.

Crewlet-SWEEngineer · handle: engineerOne seat, one agentEach seat has its own identity and memory, never a pooled worker, just like hiring a real employee.

- goal: "Ship the API"+ goal: "Ship and document it"rev 14 → 15 · liveA reorg is a diffEvery revision is kept, attributed and revertible, and applies to the running company without a restart.

Goals cascade downMission, unit goals and policies render into the planning prompt, so every plan serves the company objectives.

Ops console

What running a company looks like.

Budgets, model routing, heartbeats, the trace behind a single ticket and the revision that changed something: the surfaces an operator actually opens, one at a time.

The completion that would cross a token ceiling does not happen: the turn stops and the engine emits BudgetExhausted.

token_budgetorgOne ceiling across every seat combined.
token_budgetseatA second ceiling on one agent, checked independently.
…_max_tool_roundsphasePlan and Execute each carry their own, with a ceiling above it.
subagent_budget_fractionsub-agentA slice of whatever the turn has left, 20% by default.

4.27Mof the 10M org ceiling · last 7 days

Break spend down

PhaseShare of spendTokens

plan1.21Mllm.plan · plan_max_tool_rounds: 16, ceiling 3228% of spend

execute1.96Mllm.execute · max_tool_rounds: 20, ceiling 4046% of spend

review309kllm.review · one submit_review call, no catalogue7% of spend

subagent583kllm.subagent · subagent_budget_fraction: 0.214% of spend

auxiliary206kllm_auxiliary · budget_tokens per worker, 3k–5k5% of spend

Turn engine

Every turn is planned,
executed, then judged.

One trigger wakes exactly one agent. Each phase of its turn gets a narrow prompt, its own tool surface and, if you want, its own model. Review either closes the turn or sends it back to Plan.

Turn engine Agent runtime Event system

something arrivesiteration 1 / 3

Trigger

Slack message
Work-item updates
Merge-request review
Cron schedule
...

01PlanWhat should I do?seespolicy, role profile, roster, cataloguetoolssubmit_planactivate_tool+2 more16 tool rounds, 32 with extensionsmodelfrontier modelemitsExecutionPlan

02ExecuteDo it.seesthe plan, and the same cataloguetoolsplan.tools_neededactivate_tool+ always-on20 tool rounds, 40 with extensionsmodelcheaper modelemitsExecuteResult

03ReviewIs it actually done?seesthe plan, and what Execute didtoolssubmit_reviewand nothing elseone call, no domain toolsmodelcheap modelemitsdone | self_iterate

doneturn closes

Learning

Agents that get better every day.

Nothing here is retraining. A turn starts by reading what the agent already knows, and ends by writing back anything worth keeping — which is the whole reason the next one starts further along.

Knowledge system Agent learning Tool skills

Reads inwhat the plan phase pulls before it starts

Readat plan timeThe team’s pages, searched liveConfluence or Plane pages, searched at query time as the agent’s own user, so the backend enforces page permissions. No synced copy, and no staleness window.

Readat plan timeSimilar turns it has takenCompleted turns are kept as episodes. Meeting the same shape of problem again, an agent draws on what it did last time rather than working it out from nothing.

Writes backwhat the agent leaves for the next turn

Writeduring and afterA diary nobody else readsEvery fact an agent keeps is embedded into pgvector under its own id. Recall unions a semantic top-K with a recency top-K, so a standing rule surfaces even off topic.

Promotewhen siblings agreeA skill it wrote itselfRepeated tool work is synthesised into a skill the agent loads on demand instead of re-deriving it every turn. When several agents in a unit converge on the same pattern, it is drafted into the team knowledge base for a lead to publish.

What one turn writes is what the next turn reads.

Code sandbox

Agents that really ship code.

Generated code never runs on the engine host: it runs in an isolated box the agent drives, which is why the coding agent inside can run fully permissioned.

Code sandbox

The executor hands over a brief: the repository, and the exact change or investigation. Only a role with sandbox.enabled ever sees this tool.
The tool call is left unanswered and the whole in-flight conversation is persisted. The agent moves to AWAITING_SANDBOX and its inbox pauses, so nothing slips a turn in behind it.
Claude Code or OpenCode gets a real VM with a shell, a filesystem, and a git checkout. It clones, patches, runs the tests, and opens the merge request, under the agent’s own identity, not yours.
Minutes or hours later the completion is claimed exactly once, and the loop is rebuilt from the saved row with the findings spliced in as that call’s reply. Same turn id, so it renders as one turn.
With the code work in context, the executor replies on the thread that triggered it and updates the ticket. Review then judges the whole turn, sandbox segment included.

Open source

No proprietary runtime.

The engine is open source under the MIT licence, and it runs on infrastructure your team already knows how to operate. There is no proprietary runtime in the middle, and nothing to take on trust.

Licence