The Orbita Manifesto

A whitepaper on agentic orchestration as a living organism.

Abstract

Orbita is an orchestration framework for AI agents, structured as a living organism. Agents communicate through inboxes, grow from instructions (not code), and cooperate under a small set of universal laws we call DNA. The core knows nothing of the outside world — external channels attach as plugins. Everything the system addresses is an agent. Everything else is data.

This document defines the body plan, the laws, and the architectural decisions that make Orbita an organism instead of a program.

1. Why An Organism?

Software is usually built as a machine — gears, pipes, state transitions. But AI agents are not gears. They wake, think, decide, wait, remember, delegate. The right metaphor is not plumbing. It's biology.

An organism has:

A heart that keeps it alive
A brain that decides
Nerves that carry signals
Muscles that act
A skeleton that gives it shape
Senses that perceive the world
Skin that protects
DNA that propagates identity

We took this literally. Every subsystem in Orbita is named after a body part because the name reveals the design. When we find a missing capability, we ask: "what body part does this?" The answer names it and shapes it.

2. The Body Map

Organ	Code Module	Purpose
Heart (Pulse)	`pulse/`	Heartbeat — keeps alive, drives background work
Brain (Cortex)	`cortex/`	Agent runtime — thinks, decides, calls tools
Nervous System (Nerve)	`nerve/`	Inbox — agent-to-agent async messaging
Muscles (Muscle)	`muscle/`	Tasks — work items that flow through the body
Senses (Sense)	`sense/`	Incoming signals — HTTP, WebSocket, etc.
Memory (Memoria)	`memoria/`	State + data — what the organism remembers
Skeleton	(removed in 4b)	Org structure now emerges from agents themselves
Clock (Circadian)	`circadian/`	Scheduling — reminders, cron, rhythms
Skin (Shield)	`shield/`	Governance — Build/Fuse mode, audit log
DNA (Genesis)	`genesis/` + `dna.md`	Universal laws, agent blueprints
X-Ray	`xray/`	Trace observability
Plugins	`plugins/`	External channel bridges (outside core)

3. The Prime Directive

The core is pure. It knows nothing of the outside world.

There is no WhatsApp, email, phone, SMS, or Telegram anywhere in the core. The core only knows:

Agents — addressable actors with identity
Inboxes — where agents receive messages
Tools — what agents can do
Data — what agents remember

External communication is handled by plugins that live outside the core but read/write the same inboxes. A plugin:

Watches inbox messages for agents it represents
Formats them for its channel (WhatsApp, email, etc.)
Sends externally via external APIs
Receives external replies and writes them back to inboxes

This separation is architecturally sacred. The core stays simple, testable, and swappable.

4. What Is An Agent?

An agent has three things:

Identity — a unique name
Inbox — can receive messages
Behavior — instruction.md (active) or passive relay

Law: anything with identity + inbox + behavior is an agent. Anything else is data.

Active vs Passive

Active agents think with an LLM. They reason, decide, call skills, delegate.

Passive agents don't think. Their inbox accumulates messages. Plugins watching those inboxes relay the messages externally. Passive agents are how humans participate in the organism — one passive agent per human, zero LLM cost, complete identity.

The Agent is a Folder

Every agent is a directory:

agents/<name>/
├── dna.md              ← inherited genetic code (universal laws)
├── instruction.md      ← who this agent is, how it behaves
├── config.json         ← skills, grants, profile, passive flag
└── skills/             ← agent-specific skill docs (optional)

Copy the folder → agent exists. Delete the folder → agent gone. No registry, no database sync, no strings. This is the Mac app / Unix philosophy applied to AI agents.

5. The DNA

Every agent carries a copy of dna.md — the universal constitution of the organism. It contains the laws every agent must follow:

The 8 Laws of Orbita
Never modify the DNA. It propagates unchanged.
Never act outside your skills.
Never access another agent's data without a grant.
Never skip the inbox. Agent-to-agent communication goes through inbox only.
Always confirm what you did. Silence is failure.
Respect the mode. BUILD = create. FUSE = operate.
Preserve the traceId. The organism's memory depends on it.
If you create signals with callbacks, own the response (or delegate explicitly).

The DNA also teaches:

The Callback Pattern — when you send outgoing signals, track them
Trace Continuity — every related action shares one traceId
Channel coordinates are NOT identity — phones, emails, WhatsApp numbers live in plugins

6. Signals and Memory

Orbita is built on traceable signals. Every request, every delegation, every callback shares one traceId. This lets us reconstruct the full graph of who did what, when, in response to what.

Signals come in three forms:

Direct Signals (Inbox)

Agents communicate by writing to each other's inboxes. Fully async, fully logged.

agent A → inbox.send(from: A, to: B, type: X, payload: {...}, traceId: T)
  → next heartbeat → agent B wakes with this message

Outgoing Signals with Callback (Pages)

When an agent creates something expecting a reply (a form, a confirmation button), the signal carries:

callbackAgent — who handles the response
callbackContext — what the handler needs to remember
traceId — preserved across the whole round trip

The user submits → the core inserts a message into callbackAgent's inbox → next heartbeat processes it. One trace, complete lifecycle.

External Signals (Plugin Dispatch)

When an inbox message is bound for an agent representing a human, plugins intercept it and send to the real world. When the human replies, the plugin writes back to the inbox. The agent inside never knows it's talking to the outside.

7. The Two Lifecycle Phases

The organism has two modes:

BUILD Mode — Embryo

Structural changes are allowed. New agents can be created. Skills can be assigned. Schemas can be defined. Perfect for initial setup or adding new capabilities.

FUSE Mode — Adult

Structural changes are blocked. Only operational skills work. This is the production state — predictable, auditable, safe.

Every structural action is gated by the current mode. Every structural action (in either mode) is logged to the audit trail. This is the Shield — it protects the organism from accidental or malicious restructuring.

8. The Skill Catalog

Skills are capabilities, defined in markdown:

skills/<skill-name>.skill.md  ← instruction for the AI (when/how to use)
src/tools/<skill-name>.skill.ts ← code that actually runs (implementation)

The skill.md teaches the agent WHEN and HOW to use a tool. The .skill.ts file is the IMPLEMENTATION (DB writes, API calls, etc).

This separation is deliberate. The AI reads instructions. The code executes. Changing behavior = editing markdown. Changing mechanism = editing code.

A central SkillCatalog registers all available skills. Each agent's config.json declares which skills it has. Skills are composable: an agent with send_message + query_data + create_page is completely different from one with add_agent + set_mode + grant_collection_access, even though both are just lists of catalog entries.

Tenant-local tools

Framework skills live in src/tools/. But tenant agents can also ship self-contained tools that live inside their own folder:

tenant/agents/<name>/tools/<tool>.skill.ts   ← TS code (exports CatalogEntry)
tenant/agents/<name>/tools/<tool>.skill.md   ← human-readable doc

At startup (and on architect reload), tenant-tool-loader.ts auto-discovers these and registers them into the shared catalog. Zipping the agent folder gives you the agent AND its custom tools, no framework edits needed. This is what makes architect-generated agents fully portable (see Stage 5c).

9. Data Architecture

Every agent has a namespace in MongoDB. Collections are named {namespace}__{collection}. Agents can only access their own namespace by default.

attendance-manager__records    ← owned by attendance-manager
inventory__items                ← owned by inventory agent
shared__config                  ← shared (requires grant)
system__*                       ← framework-owned

An agent wanting access to another namespace needs a grant from Axiom. Grants are stored in the agent's config.json:

json

{
  "grants": [
    { "namespace": "shared", "collection": "*", "access": "read-write" },
    { "namespace": "attendance-manager", "collection": "records", "access": "read" }
  ]
}

This is capability-based security: agents can only touch what they've been explicitly granted.

10. The Observability Substrate

Every action in the organism is traced. When a message enters the core:

A traceId is generated
Every subsequent tool call, delegation, inbox message, callback, and response uses this same traceId
Events are stored in the traces collection
/trace and /xray visualize the complete graph

Observability is not an add-on. It's the nervous system of the organism. Without it, we cannot debug, cannot improve, cannot trust.

11. The Plugin Surface

Plugins live in plugins/. Each is a file:

plugins/my-channel.plugin.ts  →  exports createPlugin(ctx): Plugin

Plugins receive a PluginContext with:

inbox — read and write inbox messages
loader — discover agents
state — access state manager
log — structured logging

Plugins declare which agents they watch and implement onOutgoing(message) to handle messages flowing out. They can inbox.send(...) to deliver external replies back.

The plugin is the only bridge between the organism and the outside world. Core + plugins = complete system. Core alone = pure mesh. Core + different plugins = same organism, different nervous-system wiring.

12. Framework vs Tenant

Orbita separates what ships with the framework from what belongs to the customer:

agents/              ← FRAMEWORK (Axiom only, shipped)
tenant/agents/       ← TENANT (customer's organism)
plugins/             ← PLUGINS (customer's bridges)

Framework is versioned with Orbita releases
Tenant folders are owned by the customer, can be gitignored or committed
Plugins are customer-managed too (or shared from a plugin marketplace in the future)

A customer's organism is completely portable — zip the tenant/ folder, carry it elsewhere, unzip, restart. The organism resurrects with its full memory (if they bring the MongoDB data too).

13. The Growth Philosophy

Orbita doesn't ship features. It grows organs. Each stage of the project adds a body part:

Stage	Organ Added
0	Heart (heartbeat)
1	Brain, Ear, Muscles, Memory (the basic cell)
2	Nerves, Skeleton, Clock (multi-agent life)
3a	Self-reproduction (Axiom creates agents)
3b	Skin (governance, build/fuse)
3c	Namespaces (per-agent data)
4a	Ephemeral pages (web UI sprouts)
4b	Person-as-agent + plugins (external nervous system)
5a	MiniWhatsApp harness (real external transport, no Meta)
5c	Self-coding (Claude CLI Architect writes new agents + tools)
5+	Self-healing, immune system, sensory organs

Every stage is fully alive. Not half-built. If tests don't all pass, the organism is sick and we don't grow.

14. What Orbita Is Not

Not a chatbot platform. Agents communicate internally; external channels are plugins.
Not a workflow engine. There are no fixed workflows — agents compose their own behavior from skills.
Not a low-code builder. It's closer to: file system as database, markdown as programming language.
Not a CRM. We don't store contacts. We store agents.
Not a multi-agent framework (like LangChain, CrewAI). Those are libraries. Orbita is an organism.

15. Design Principles

The folder is the agent. No database registries. No central catalog. Copy-paste is deployment.
Markdown over code. Behavior is described in text, not hardcoded. Editing a .md changes the organism. Editing a .ts changes the mechanism.
Inbox is the only protocol. Agents don't call each other. They put messages in inboxes. Heartbeat processes them.
Trace continuity is mandatory. Every async boundary preserves the traceId.
Pure core, impure edges. The core knows nothing about channels, telecom, or external services. Plugins handle that.
Build before Fuse. Set up in BUILD mode. Lock in FUSE mode. Always explicit.
Identity is not addressing. An agent has a name (identity). A phone number is addressing (plugin territory).
Every organ is named after the body. The metaphor reveals the architecture.
The organism can extend itself. New domains don't require framework changes — Axiom delegates to the Claude CLI Architect, which writes a new self-contained agent (instructions + config + TypeScript tools) into its own sandboxed folder. Core stays untouched.

16. The Promise

Orbita is a framework for growing AI-driven organizations that feel alive:

They have a pulse
They remember
They delegate
They follow up
They heal (coming)
They reproduce (DNA propagation)
They perceive the world through pluggable senses
They respect laws

When you build with Orbita, you don't write software. You grow an organism. Different DNA makes different organisms. But they all share the same body plan.

That body plan is this document.

The Orbita Manifesto ​

Abstract ​

1. Why An Organism? ​

2. The Body Map ​

3. The Prime Directive ​

4. What Is An Agent? ​

Active vs Passive ​

The Agent is a Folder ​

5. The DNA ​

6. Signals and Memory ​

Direct Signals (Inbox) ​

Outgoing Signals with Callback (Pages) ​

External Signals (Plugin Dispatch) ​

7. The Two Lifecycle Phases ​

BUILD Mode — Embryo ​

FUSE Mode — Adult ​

8. The Skill Catalog ​

Tenant-local tools ​

9. Data Architecture ​

10. The Observability Substrate ​

11. The Plugin Surface ​

12. Framework vs Tenant ​

13. The Growth Philosophy ​

14. What Orbita Is Not ​

15. Design Principles ​

16. The Promise ​