Context Boundaries

Qué puede ver cada agente, qué puede escribir y qué no puede tocar nunca. Los contracts que evitan que un agente corrompa a otro.

Propósito

Esta página documenta los context boundaries entre los agents. Los boundaries son los contracts que evitan que un agent corrompa a otro y que hacen el sistema auditable.

Los agents son:

Coordinator — el main control agent.
Coding Assistant — el implementation arm.
Research Worker — el research specialist.
Media Agent — el entertainment specialist.
Web Agent — la browser automation capability.

Cada agent tiene su propio context. Los boundaries los enforce el process model del framework y los filesystem permissions.

Process model

Cada agent corre en su propio proceso. Los procesos están aislados a nivel del OS. La comunicación entre agents ocurre a través de:

HTTP (para el Research Worker y el Media Agent, que exponen gateways).
Function calls (para el Coding Assistant, al que invoca el Coordinator).
La herramienta browser (para el Web Agent, que es una thin layer sobre el browser).

Los procesos están supervisados por launchd (macOS) o systemd (Linux). Un crash en un proceso no afecta a los demás.

Filesystem boundaries

Cada agent tiene su propio working directory y su propia memoria. El filesystem layout:

Path	Owner	Other agents
`{workspace-root}/`	Coordinator	Read-only
`{workspace-root}/{project}/`	Project's agent	Read-only
`{workspace-root}/memory/`	Coordinator	Never
`{workspace-root}/skills/`	Coordinator (activates)	Read by all
`{workspace-root}/sessions/<id>/`	Session's agents	Never
`{research-root}/runs/<mission_id>/`	Research Worker	Read by Coordinator
`~/.openclaw-scout/`	Scout (Research Worker)	Read by Coordinator
`~/.openclaw/media/outbound/`	Media Lab Server	Read by Media Agent

Los boundaries los enforce:

Process isolation. Cada agent corre con una user identity distinta donde el OS lo permite.
Filesystem permissions. Cada directorio tiene permissions que evitan writes no intencionados.
Tool sandboxing. Las herramientas del Coding Assistant corren en un sandbox que evita writes fuera del workspace.

El Coordinator puede leer cualquiera de estas ubicaciones. Los demás agents pueden leer lo que necesitan para hacer su trabajo y escriben solo en sus propias ubicaciones.

Memory boundaries

La memory layer está documentada en detalle en Memory and Context. El resumen:

MEMORY.md se carga solo en la main session. Los specialized agents no la cargan.
Los daily logs son per-agent.
El Research Worker tiene su propia workspace memory ({research-root}/) para mission artifacts.
El Media Agent no tiene memoria persistente.

El Coordinator es el único agent que puede editar MEMORY.md. Los demás agents no pueden.

Tool boundaries

Cada agent tiene una lista de tools que puede invocar. La lista se configura por agent en la configuration del framework.

Agent	Tools (examples)
Coordinator	Todas las tools (es el dispatcher).
Coding Assistant	`codex`, `git`, `npm`, `pytest`, file manipulation tools (dentro del sandbox).
Research Worker	`research-cli`, `run-research`, `tavily`, `duckduckgo`, `google-search`, `youtube-transcript`, `yt-dlp`, `perplexity`.
Media Agent	`chromecast`, `vlc`, `media-playback`, `media-lab-server`, `torrent-finder`, `subtitle-finder`, `dubbed-finder`, `media-info`.
Web Agent	`browser` (la herramienta browser de OpenClaw).

Las tools del Coding Assistant están sandboxed. Las tools de los demás agents corren en su propio proceso y tienen los permissions de ese proceso.

Communication boundaries

Los agents se comunican a través de:

Request/response. El Coordinator envía una request a un agent; el agent le devuelve una response.
File system. El Research Worker escribe artifacts a disco; el Coordinator los lee bajo demanda.
Gateway HTTP. El Research Worker y el Media Agent exponen gateways HTTP. El Coordinator los llama por HTTP.

Los agents no se comunican a través de:

Shared memory. No hay región de memoria compartida.
Environment variables. Los agents no leen las environment variables de los demás.
Direct function calls. El Coordinator llama a los agents por sus interfaces públicas (HTTP, CLI).

Los boundaries están diseñados para que un agent se pueda reemplazar sin afectar a los demás. El Coordinator no sabe cómo implementa su trabajo un agent; conoce el contract.

What each agent can never touch

Agent	Cannot touch
Coordinator	El sistema del usuario (no shell access por defecto).
Coding Assistant	Nada fuera del workspace del proyecto (sandboxed).
Research Worker	La memoria del Coordinator. El sandbox del Coding Assistant.
Media Agent	Los artifacts del Research Worker. El sandbox del Coding Assistant.
Web Agent	Nada fuera del browser. El filesystem del usuario.

Estos constraints los enforce:

El process model (no hay recursos compartidos).
El tool sandboxing (Coding Assistant).
Los filesystem permissions.
La configuration del framework (qué tools se exponen a qué agent).

What each agent must do

Agent	Must
Coordinator	Loguea cada request y cada response. Hace clarifying questions.
Coding Assistant	Nunca escribe código directamente. Siempre pasa por el sub-agent.
Research Worker	Checkpoint tras cada paso. Valida los artifacts contra los schemas.
Media Agent	Confirma el target device antes de enviar un playback command.
Web Agent	Usa el accessibility tree, no screenshots, para las acciones.

Las "must" rules son parte del contract. Las violaciones son bugs.

Boundary enforcement