Loa/Arbor
English
  • English
  • 简体中文
  • 日本語
  • Español

Loa Arbor

Stop building chatbots. Build a team.

Arbor runs agents, plain code and people together, each doing its part. Start with one agent and add a teammate at a time.

Example: Shared coding session. A product manager and two engineers shape the plan in one conversation, and agents pick up the work, each coming back with a branch for a person to approve.

Architecture

Your producta browser or mobile app with the client library, your own backend, or a webhook for SMS and email
You and your coding agentClaude Code or any agent in a terminal, with the arbor CLI and the docs it ships
Arborruns your app's actors and agents, one saved step at a time
Modelsas many providers as you like, any that speak the OpenAI or Anthropic API; each agent picks its own
Tools and servicesyour own code, MCP servers, and the HTTP endpoints you allow
Postgresevery step, in one write; one node can run on a SQLite file

The building blocks

Actors

Plain code with saved state, a function over the next batch of messages. Routing, timers and status labels are actors that never call a model.

Agents

An actor whose function is the model loop. It builds the context, calls the model, runs the tools the model asks for and repeats until it replies. Each agent picks its own model and provider, so one app can mix them, and a new revision can change them.

Subagents

An agent starts children for work that can run in parallel. They message each other while both are working, so a parent can correct a child halfway through and a child can report progress before it's done.

People in roles

People join a session in the roles the app declares, and each sees only what is meant for them. A message addressed to one person goes to that person's stream alone.

Relays

A ready-made actor that sends each message to its audience, everyone, one role or one person, so people and agents share one record.

Tools, and calls that wait

Tools come from your code or from MCP servers. A call can wait for a person to approve it, for an answer on someone's screen, or for outside work to finish, for minutes or days and across restarts.

Memory and documents

One store of notes, each with a reach, a session, a partition or the whole app, and an audience. Documents are named and versioned, and can be held to a schema.

Partitions and schedules

A partition groups sessions by customer, campaign or tenant, so what was noted on Monday is there on Tuesday. A schedule posts a message on a timer, with no one having to write in.

Skills and programs

An agent loads a skill, its rules and its tools, only when it needs it. With the run tool, the model writes a short program over its tools, and every call inside it is still a saved step.

Connections and workspaces

An assistant can act for one person, with that person's own account on an MCP server; the token never reaches the code, the model or the record. A workspace gives an agent its own clone of a repository, where every command runs in the OS sandbox.

Every block, with its code

Overwhelmed? Don't be.

Arbor was designed to be written and run by coding agents like Claude Code. It's built for the command line first, with a console operators can use to keep track of things.

Your coding agent writes the app

A coding agent builds and manages the app from a terminal, with a person reviewing. A person can run the same commands by hand.

The docs ship with it

arbor docs search and arbor docs get work offline and match the version that's running. A new project gets an AGENTS.md that points the agent there.

Every command answers in JSON

Every command takes --json. An error is one JSON object with a stable code, the fields at fault and whether a retry can help, and the exit code says what kind of error it was.

Changes are staged, then published

The agent stages settings into a draft, a person or the agent reviews it, and one command publishes it as a new version. A command that destroys something runs only with --yes, and a script is refused rather than left waiting for a keypress.

Your product calls one HTTP API

Your product opens a session, posts each message and reads one stream of everything that happens, over HTTP or with the client library for browsers and phones.

A console for operators

The console comes with Arbor. It shows each session's people, what it has spent against its budget, and a graph of the app's actors drawn from the app itself.

The developer workflow

Examples

const coach = agent('coach')
  .wake('chat')
  .hooks({ beforeTurn: async (ctx) => { /* fold what it heard; a "NOTE: " line goes to the staff */ } });

const lobby = relay('lobby', {
  roles: ['customer', 'staff'],
  messages: {
    text: {},
    note: { for: { role: 'staff' } },
    whisper: { for: { participant: 'to' } },
  },
  readers: [coach],
  writers: [coach],
});

const desk = agent('desk', { instructions })
  .wake('chat')
  .participants(['customer', 'staff'])
  .subagents(breakout);

export default bundle({
  app: 'seed-relay',
  roots: [lobby, coach, desk],
  session: { roles: { customer: { max: 2, principal: true }, staff: { max: 3 } }, exposed: [lobby, desk] },
});

From a single actor to a room of customers, staff and agents, one block at a time. Each step is one of the seed apps in Arbor's repository, and the count is its lines of code, comments left out. The code with each step is cut down, with what the step adds marked.

  1. Plain code that answers each message. No model.

  2. Give it instructions and the same actor becomes an agent, with a model loop inside.

  3. The agent starts researchers for questions it can look up in parallel, and keeps notes for this conversation and for the whole shop.

  4. A member of staff joins the same conversation in a role of their own. The agent knows who said what.

  5. A refund over $100 waits for a member of staff to approve it, for minutes or days, across restarts.

  6. A relay sends each message to its audience, to everyone, to staff only or to one person. A coach agent hears it all and writes notes for the staff.

Fuller examples, in code and prose

What Arbor handles for you

A crash loses at most one step

Each step is saved in one write before the next begins. If a node dies, another picks the actor up after the last saved step, and no finished model or tool call is made twice. A session that is waiting uses no compute.

Spending is exact, and capped

A model call's cost is saved in the same write as its answer, so the bill and the record can't disagree. Caps on an actor, on an agent and its subagents, or on a session can warn, refuse further calls, or stop.

Rules on every tool call

For each app or agent, a tool call can be allowed, warned about, blocked, halted or held for a person. If a node dies mid-call, a read-only or repeatable tool runs again; any other is not, and the agent is told the outcome is unknown, unless the tool's author chose to hold it for a person.

Any conversation can become a test

Copy a real conversation at the step where it went wrong, give the copy a new prompt, model or tool, and compare the two, with what each cost. The copied steps aren't run again, and for each kind of call you choose who answers: the live system, the recorded answer, or a stand-in. A tool that sent an email in the original doesn't send it again.

New versions never change a running conversation

A session keeps the version of the app it started on until it closes. A new version can take a share of new sessions first.

Nodes hold nothing

Any node can carry on any actor, so you can add and remove nodes while Arbor runs. One node runs on a SQLite file; a fleet shares Postgres, Redis and a blob store.

Every step is traced

Where the time went, what each actor decided and what it cost come from the same saved steps, so they always agree. Traces are OpenTelemetry, and a console ships in the binary.

Tested

About 2,900 Go tests run with the race detector, plus an integration suite against Postgres. Each storage interface has one test suite that every implementation must pass.

Benchmarks

10k
commits a second (10,414) across 16 sessions, on Postgres on one laptop
1.2ms
median commit in that same test; 0.6 ms for one actor on its own
1,086
turns a second through one node, 200 sessions at once, on Postgres and Valkey, with a scripted model on one development machine (1,093 on a second run)
1.6ms
the slowest 1% of commits in that same test

How each number was measured

When Arbor isn't a good fit

  • Milliseconds matter, as in a medical device or a self-driving car. Arbor puts reliability and safety ahead of speed: every step is written to the database before the next one starts. On one laptop that write takes a median of 0.6 ms, under 0.8 ms for the slowest 1%, about 2 ms when four actors share a session, and about 12 ms with sixteen. Beside model and tool calls that take hundreds of milliseconds or more, the overhead is negligible.
  • You want a general-purpose programming platform. Arbor is a durable ledger with a lightweight actor model, for building rich agentic business processes with little effort. It's like a workflow engine, without the rigidity. Apps are short TypeScript, written to be authored by coding agents, and reach the outside through tools and MCP servers.
  • You want a library inside your own process. Arbor is a server you run and call over an API.
  • You need voice. It isn't built.
  • You need a vendor behind it. There's no hosted service or support contract today. If that's what's stopping you, let's talk. Arbor is pre-release, and stored data doesn't survive a change to its schema yet.
  • The job is one prompt and one answer. A single stateless call gains little from a durable runtime.