Skip to main content
Agent is the base worker runtime in openboa. The important distinction is:
  • the business is the durable operating subject
  • the agent is an evolvable worker
  • Chat, Work, and Observe add business meaning on top of the worker runtime
So agent is not the product by itself. It is the reusable execution substrate that product surfaces compose with.

​
Core thesis

Agent should stay valid even before any higher-layer product surface exists. Its job is to provide one bounded worker runtime that can:
  • execute through sessions
  • assemble context and bootstrap files
  • use tools inside a controlled environment
  • manage local workspace, memory, and auth state
  • wake, continue, and follow through across turns
The runtime should stay domain-agnostic. It should not learn room semantics, work semantics, or operator governance semantics directly.

​
Primary responsibilities

At the canonical level, Agent owns:
  • session lifecycle
  • harness execution loop
  • environment and sandbox boundary
  • runtime memory and learnings substrate
  • provider execution and tool use
  • worker-local traces and progress append behavior

​
What Agent does not own

Agent should not become the owner of:
  • shared chat transcript truth
  • business commitments and work state
  • operator-facing audit and evidence meaning
Those meanings belong to higher layers. The core runtime stays reusable by letting upper layers attach capability packs, prompts, tools, and context.

​
Boundary with other surfaces

​
Relationship to Chat

Chat does not define the agent core. Instead:
  • agent registration exposes a runnable worker identity
  • chat binding makes that worker a participant in rooms, DMs, threads, and mentions
  • chat-specific tools, prompts, and context make the runtime chat-capable

​
Relationship to Work

Work is not session mechanics. It sits above the runtime and answers business questions such as:
  • what commitment exists
  • who owns it
  • what state it is in
  • what result became company-owned value
Agent may produce execution relevant to that layer, but it does not define the work object.

​
Relationship to Observe

Observe should read execution evidence without taking over the runtime. Agent owns:
  • the session
  • the harness run
  • worker-local traces
Observe owns:
  • the operator-facing explanation of that execution
  • evidence stitching
  • degraded or blocked visibility

​
Why Agent is its own top-level surface

If Agent is flattened into a generic implementation appendix:
  • upper-layer products start reaching directly into runtime internals
  • the system drifts toward chat-defined or work-defined workers
  • provider and environment seams become harder to preserve
Keeping Agent first-class protects the rule that the worker runtime remains reusable while higher layers add business meaning.

​
Current code shape

The current repository already reflects this split:
  • src/agents/ holds the core runtime
  • Session is the primary execution object
  • the harness runs the bounded brain loop
  • higher layers are expected to make the runtime chat-capable, work-capable, or observe-capable
The detailed runtime contract is documented separately in Agent Runtime, but the product-level meaning belongs here.