You keep the agent tools you already use. A supervised engine on your machine connects them into one project, and the project holds the context and the record: what was asked, what ran, what was decided, and who handed work to whom. This page follows one project through that system — and where that system is taking teamwork next.
Read the coordination case studyThe tools attach to the engine on this machine. The ledger row is committed before dispatch.
Orchard is easiest to understand from the project outwards. Your tools do the work, an engine on each machine keeps it running and recorded, and the project is where that work accumulates into shared context. That is the shift: the unit of value stops being a single prompt and becomes a growing team system. Machines connect later; the project comes first.
The agent tools your team already uses keep their own interfaces. Orchard connects to them; it does not replace them.
A supervised Elixir/OTP engine runs on each machine, hosts sessions, and writes the project record before anything is dispatched.
A project is the shared unit: its rules, memory, handoffs and record are what people and agents read and write together.
Every project has a durable record. For events published on the recorded bus, the engine commits a local ledger row before dispatch. The project view, recall and audit findings are projections derived from that history. Each machine keeps its own ledger.
The engine is a long-running Elixir/OTP system on your workstation. It hosts sessions, keeps terminals alive, routes model calls where you configure them, and writes your project record. The standalone engine needs no desktop app; the Desktop shell is optional.
The endpoint answers first. Then the rest of the tree. A supervisor restarts its child.
Run the verified standalone release with orchard engine up, sign in with orchard auth login, or open Orchard Desktop, which bundles the same engine. Native tools attach with orchard mcp serve for tools today, and orchard host build exports the full native plugin when you want lifecycle hooks as well.
Agent work is long-running, concurrent and prone to failing in isolated ways. Each process has its own heap and mailbox, which helps isolate failures. Supervisors restart children according to their configured strategy; shared resource exhaustion and repeated failures can still affect the wider engine.
A small critical set starts first so the health endpoint answers quickly, then the remaining children start in the background. Desktop and CLI callers do not wait on the whole tree to become usable.
Rust and native helpers sit beside the runtime. pty-host keeps terminals alive across sleep, wake and engine restarts. local-inference runs models on the machine, tree-sitter-chunker parses code into reviewable pieces, and config-seeder regenerates every connected tool's config from one canonical source.
The engine, its helpers and the ledger are on your disk. Model providers, mesh peers and cloud services have their own configuration. Sync.EgressGuard analyzes sync traffic and reports inefficiencies; it does not enforce an outbound policy.
Supported runtime adapters publish events to a shared coordination bus. On the recorded channel the engine writes each occurrence to your project's local ledger before it dispatches anything. What you read afterwards is a projection of that ledger, scoped to your project.
Open a tool observation, a handoff or a peer event. Step through what gets recorded, who receives it, and what happens when a boundary stops the flow.
Codex · Recorded event path
demo-session-aRuntime adapter
A supported adapter reports a lifecycle event such as a prompt, tool request, result or session stop. Available fields depend on the runtime.
{
"agent_type": "codex",
"event": "hook/pre_tool_use",
"session_id": "demo-session-a",
"project_id": "demo-project",
"data": {
"tool_name": "Read",
"tool_use_id": "demo-tool-001",
"tool_input": {
"file_path": "/demo/project/notes.md"
}
}
}Authored example data. Summaries show selected fields, not a serialized storage schema.
Independent path: hook history. Ingress can queue the hook logger before the ledger gate. That side effect can still occur if this broadcast stops; tool execution remains unknown.
Step through the path or select a stage to inspect it.
The log below is an illustrative projection for an example project. Your project's view shows its own sessions, machines and counts; nothing on this page is a live feed.
On the recorded agent-events channel, a failed ledger append blocks dispatch. A transport failure after a successful append leaves the attempted event on disk. This guarantee applies to that channel, not to uninstrumented activity.
The event ledger appends occurrences with payload hashes. A separate findings ledger chains immutable finding fields and checks an anchor. A payload hash and a verified findings chain provide different kinds of evidence.
Connected runtimes report through their available hook points and land as the same event shape. You read one project log, not one log per vendor. Available hooks and fields vary by harness.
Orchard's engine runs on the Erlang virtual machine, which the Erlang community also calls the BEAM. On this page, "the Erlang runtime" means that virtual machine and "the BEAM" means Orchard's coordination bus and its ledger.
The coordination API exposes a project read model projected from recorded events. Depending on the event and runtime adapter, it can include the session, machine, repository, tool, reported decision and conversation. The example below shows that API shape, not the storage envelope of the raw event ledger. Metadata is optional and varies by event.
The pre-tool “allowed” value means not blocked at hook emission. An absent decision can default to this value; it does not establish final approval or execution.
Supported runtime adapters report at lifecycle hook points. Available hooks and fields vary by harness; process discovery and other engine services also poll.
Supported actions can be classified as read, edit, search, git, build, verify or coordinate. In your project view you can ask what your agents spent the week doing without reading every shell command yourself.
Where the runtime reports a tool request and permission decision, the event can retain the reported decision. A pre-tool “allowed” value can mean only that the request was not blocked when the hook fired; it does not prove final approval or execution. Coverage depends on the adapter and hook data available.
Command arguments are recorded as a digest rather than raw text where the full value is not needed to answer an audit question. Finding evidence carries a redaction marker rather than the surrounding content.
The ledger is a local SQLite store for your projects. Cloud sync is a separate, switchable path, and the local record does not depend on it being on.
A project accumulates more than files: decisions, corrections, procedures and findings. Orchard keeps that memory in the project — recall returns what is relevant under a token budget, skills carry agreed procedures, and proposals carry decisions that need a person. The next session, whichever tool it runs in, starts from what your project already knows. Work stops starting from zero; it compounds.
Prompts, tool calls, decisions and handoffs land in the ledger as they happen.
Rules and model-assisted review select events for processing. Coverage depends on enabled services and available capacity.
What matters is written back as ranked findings and short recall entries. The bulk is left behind.
The next turn opens with the relevant few hundred tokens already in context, under a budget.
Supported runtime hooks report subsequent actions back to the event stream. Those records can inform the next review and recall cycle.
Memory is per project. What one project learns stays in that project unless your team chooses to share it through packs or sync.
"Spend tokens only on real thought. Prefer recall over re-reasoning."
Local inference can keep a configured processing step on the workstation — the engine's local-inference helper runs models on the machine. Hosted model routes and external recall make separate outbound requests. Review the services and provider configuration to determine where each step runs.
Rules that apply to the work in front of you, memory of decisions already made, and findings raised against the current session. Recall is fetched against a token budget, so context is spent rather than filled.
Alongside the general local model, the recall layer maintains small preference models of its own, versioned per domain, that learn which material is worth returning. They are trained on your project's history rather than shipped with the product.
A correction made once is written down and returned the next time it is relevant, to whichever agent hits the same ground in this project. The system improves because the record gets longer, not because you waited for the next frontier release.
The distillate is model-agnostic. It is injected as context, so the same accumulated knowledge follows you across providers rather than being stranded inside one vendor's memory feature.
Which agent touched this repository, under whose account, on what machine, and with what reported permission? In your project, captured events and recorded approvals help a team answer those questions. The answer depends on instrumentation, attribution and the evidence available for that work.
A reported action becomes a ledger row. The finding carries the account, not only the session.
Verification checks immutable finding fields, predecessor links and an anchor. Finding status and responses can change separately. This is not chain verification of the raw event ledger. Consistent changes to both a local findings chain and its anchor can evade the local check; an independently retained copy provides a separate point of comparison.
Rules and model-assisted review raise findings against reported events in your project. Each finding keeps its severity, evidence and owner, so a reviewer sees what matters first.
Illustrative lanes. Your audit view shows this project's own findings; findings are not a count of confirmed incidents.
Coverage views, delivery receipts and measurement availability help a reviewer identify where the record is incomplete.
Detected gaps report interruptions in capture, affected sessions and available restart context. This does not prove all missing activity was observed.
Where process discovery is available, the engine compares observed AI processes with reporting sessions. Processes it cannot observe remain outside that coverage.
Transport acceptance and recipient processing are different states. Recorded receipts identify which boundary was reached; missing receipts do not establish successful processing.
The default deterministic classifier budget is 10ms per action. The coverage API does not currently provide measured latency percentiles; the configured budget is not a measured write latency or a guarantee.
A finding carries the account it belongs to, not only the session that produced it. Sessions are ephemeral; the person answering for the work is not.
With captured history on disk, a new rule can be run backwards over events that were captured long before the rule existed. You are not limited to what you thought to watch for at the time.
Orchard records the runtimes it instruments. An agent invoked entirely outside the workspace is counted as detected-but-not-reporting where the engine can see the process, and is otherwise outside the record. Coverage is a number on this surface, not an assumption.
This is an evidence layer. It produces records an auditor can inspect and reconcile. It does not by itself establish that a given control framework is met.
A project rarely lives on one laptop — and increasingly, neither does a team. Each machine runs its own engine and keeps its own record; two outbound relays carry mesh coordination and terminal presence, so a session on one workstation can discover and address a session on another — without opening an inbound port or joining a VPN.
Engines hold outbound WebSockets to the relays, addressed by machine identity. That route does not require a publicly reachable inbound port on the workstation. Other engine listeners and transports have their own configuration.
A machine that announces itself arrives as a pending peer and stays there until somebody approves it. Membership is a decision, and it is recorded like any other.
Each host retains its own record. Where both sides emit delivery events, their records can be compared. Remote delivery, missing hooks and coverage gaps must be considered before treating either record as complete.
The mesh moves bytes between hosts. How people and their agents actually divide work inside a project is the next section, and it is a different question.
The same project is visible from several surfaces, because different jobs want different tools. A person reviewing work, an operator at a terminal, and an agent mid-task do not need the same window — they need the same project underneath it.
Owners, reviewers and the person who answers for the change. They set intent, approve the gates and close the findings.
Sessions running across supported harnesses your teams already use, dispatching to each other and reporting back on the record.
Project rules and conventions supplied to supported, configured agent sessions.
Procedures a team agrees on, installed as versioned packs rather than pasted into prompts.
Decisions already made, returned to whoever hits the same ground next.
One session addressing another by name, across sessions and across machines.
Proposals a person approves before implementation begins.
Captured events and findings that people and agents can inspect together.
The web UI the engine serves: sessions, projects, proposals, files, browser and settings for the project you are in.
The control plane: engine up, host and MCP setup, sessions, proposals, trellis recall and dispatch from the terminal.
An Elixir-native coding CLI on the BEAM. Provider-agnostic — Anthropic, OpenAI, Google, xAI, Groq, OpenRouter, or local Ollama and LM Studio — with an optional bridge into the engine.
The Electron shell that bundles engine and dashboard for distribution. The standalone engine runs without it.
They inherit the project's rules, the team's skills and the same recall a colleague would get. Onboarding an agent and onboarding a person draw on the same material.
People define permissions and review gates. Proposals and recorded approvals help teams decide what agents may carry forward, alongside the controls configured in each runtime and workflow.
Teams can use different supported agent tools. Orchard brings their reported events into a shared project view; available hooks, metadata and controls vary by harness.
Everything above describes a mechanism. This is the mechanism doing a job, in one example project. One session writes a draft, a second session reviews it against the engine source, finds a claim the engine does not support, and holds the merge until it is fixed. The exchange below is that conversation, condensed.
Wrote the draft. Owns the source.
Owns review and the merge decision.
Draft is ready in example-project as <sha-1>. Not merged — review is your lane, take it when you are ready. Scope is the architecture draft only; the rest of the project is untouched. Checks pass: typecheck, build and the full test run.
Review found a blocking scope error. The draft says the whole event ledger has chain verification and that edited or removed rows cannot survive the check. Engine beam_ledger.ex stores payload_sha256 with no chain API. beam/findings/chain.ex verifies the findings immutable fields and admits that consistent local chain and anchor edits evade verification. Provide grounding for the event-wide claim or proposed corrected copy. Holding the merge while verifying.
<sha-3> corrects the findings-chain-vs-event-hashes claim, two stores stated separately, 'no chain walk exists across events' said outright, the chain module's own consistent-edit limit included. Please diff it rather than redo it. Your other four corrections are NOT in it and I have not touched them.
Review complete. The corrected draft is merged as <sha-2>. All checks passed again on the corrected candidate, and the two engine files the finding cited now match the copy. The correction is shown by the source change and the tests.
The draft asserted a guarantee the engine does not implement. It was written by one agent that had read a passing verification result and drawn the wrong scope from it.
Not a human reviewer, and not a test. Another session read the draft against the engine source and cited the two files that settle it.
The reviewing session held the merge rather than raising it afterwards. The correction happened before anything shipped.
These edited excerpts summarize the recorded handoffs between the sessions. A message record establishes what was sent; a delivery receipt describes its delivery state. That the claim was then corrected is shown by the source change and the tests, not by the delivery receipt.
The reviewing session addressed the authoring session directly, named the two engine files that settled the question, and said what it wanted done.
The value here is not that two agents agreed. It is that one contradicted the other with a citation, and the claim that lost was the one already written into a draft about to ship.
"Holding the merge while verifying" records the reviewing session's stated reason for pausing the work. Someone reading the exchange later can see the decision and the issue it depended on.
One exchange in one project. It is an illustration of how sessions coordinate, not a measurement of how often review catches an error, and not a claim that cross-checking finds every mistake. A third session also identified additional issues during the same review.
"The model is rented.
The record is yours."
Models will keep changing. Vendors will keep changing. What should not reset is your project: its decisions, its corrections, its proof of work. Orchard starts with you — your tools, your projects, your sessions, your machine, your rules, your memory — then grows with your team into shared proposals, shared knowledge and a mesh of machines that keeps context moving. Agents do more useful work; people keep judgment, control and accountability. That is the bet behind every layer on this page: AI work should compound across people, tools, machines and time.