# Flujo de trabajo entre agentes

Transfiere una decisión, una corrección de implementación y un contexto acotado entre agentes identificados mediante los contratos existentes del SDK y MCP.

- Canonical: https://docs.xmemo.dev/es/docs/operations/cross-agent-workflow
- Locale: es-ES
- Content-Locale: es-ES
- Canonical-Content-Digest: 601017a1cc889872d5526e3d5cb8ee1ac73c89512eb78d284d88811d2349b611
- Edition-Digest: f21edc6c8ce35a05781a70614c175768f51d42b060c7b650dfde5f10b9dc4185
- Source-Revision: sha256:9e1f7f01cc46df74b247f9cecea3b932f1b046cd1751624acdfd046a7b7fedd2

## Una transferencia, dos superficies existentes

Una transferencia entre agentes no añade una API nueva. El agente que escribe puede usar las ayudas de flujo del SDK de TypeScript taskStart, recordDecision, recordBugFix y taskEnd; el agente receptor puede usar la herramienta MCP recall_context o el método del SDK recallContext. Los nombres de los agentes que aparecen abajo son valores de atribución que transportan las solicitudes existentes; el acceso siguen autorizándolo la clave de API o la concesión OAuth y los ámbitos memory:read / memory:write.

- Claude escribe la decisión mediante su adaptador conectado o cliente del SDK.
- Codex recupera el contexto acotado, registra la corrección y cierra su tarea.
- Claude vuelve a llamar a recall_context y recibe la decisión y la corrección compartidas cuando el propietario autenticado y el ámbito solicitado lo permiten.

## La cronología de la transferencia

El orden del ciclo de vida es taskStart → recall_context → recordDecision → recordBugFix → taskEnd → recall_context de otro agente. taskStart y taskEnd usan por defecto un tipo de memoria de trabajo con estado started y completed; recordDecision y recordBugFix usan por defecto memoria semántica. Todos los helpers de captura del SDK resuelven a CaptureResult, así que el llamador debe inspeccionar shouldCapture antes de asumir que se escribió una memoria.

```text
1. Claude: client.taskStart(...)
2. Codex: recall_context({ query, max_items, max_tokens })
3. Claude: client.recordDecision(...)
4. Codex: client.recordBugFix(...)
5. Codex: client.taskEnd(...)
6. Claude: recall_context({ query, max_items, max_tokens })
```

## Escribir la decisión con el SDK

Los métodos del SDK usan los campos existentes de AgentWorkflowOptions. Mantén estables source, la identidad del agente, sessionId, taskId y scope durante la transferencia; no pongas la clave de API en las opciones ni en el contenido registrado.

```ts
const scope = 'memory-os';
const sessionId = 'handoff-session-1';
const taskId = 'handoff-1';

await claude.taskStart('Review the deployment adapter', {
  source: 'claude', sessionId, taskId, scope,
});
const decision = await claude.recordDecision(
  'Use the hosted network MCP transport for remote agents.',
  { source: 'claude', sessionId, taskId, scope },
);
if (!decision.shouldCapture) {
  throw new Error('Decision was not captured: ' + decision.reason);
}
```

## Recuperar, corregir y cerrar la tarea

MCP recall_context es el paquete acotado de contexto con varias memorias y requiere memory:read. El método recallContext del SDK llama a POST /v1/recall/context y devuelve el objeto JSON estructurado. Codex puede usar cualquiera de las dos superficies para leer y después usar las ayudas existentes del SDK para corregir el error y cerrar la tarea.

```ts
const context = await codex.recallContext(
  'deployment adapter decision and current bug',
  { scope, maxItems: 6, maxTokens: 1200, preferWorking: true },
);

await codex.recordBugFix(
  'Fixed streamable-http token identity fallback.',
  { source: 'codex', sessionId, taskId, scope },
);
await codex.taskEnd(
  'Deployment adapter fix completed for handoff.',
  { source: 'codex', sessionId, taskId, scope },
);
console.log(context.version, context.items);
```

## La lectura MCP equivalente

En la superficie MCP pública, usa la herramienta existente con nombre separado por guion bajo y sus argumentos públicos en snake_case: query, max_items y max_tokens. El perfil conectado proporciona el propietario autenticado y la identidad del agente; el servidor anota los elementos devueltos con el objeto de límite del agente. max_items y max_tokens acotan todo el paquete de contexto. La herramienta devuelve una respuesta de texto pública que comienza por ### XMemo Context.

```text
recall_context({
  query: "deployment adapter decision and current bug",
  max_items: 6,
  max_tokens: 1200
})
```

## Lee los campos de límite, no solo el contenido

El resultado de recall lleva la anotación del objeto de límite de agente existente. Si Codex lee una memoria escrita con agent_id=claude, la relación es other_agent y la propiedad es other_agent; si el agent_id lógico coincide pero el hash de instalación es distinto, la relación es same_agent_other_instance. La coincidencia de agent_id y agent_instance_id_hash es self. boundary_authority sigue siendo attribution_only, y current_agent_trust solo es token_bound cuando la fuente de identidad está vinculada al token; en caso contrario es client_asserted.

```json
{
  "relation": "other_agent",
  "ownership": "other_agent",
  "current_agent_id": "codex",
  "current_agent_trust": "client_asserted",
  "boundary_authority": "attribution_only",
  "memory_agent_id": "claude",
  "explanation": "memory agent_id differs from this caller"
}
```

## Reanudar con el mismo ámbito y una consulta acotada

La recuperación posterior de Claude usa la misma cuenta autenticada y el mismo ámbito, pero sus propios valores agent_id y agent_instance_id. La memoria solo sigue compartida cuando la credencial del llamador, el ámbito memory:read, el límite del propietario y los filtros de recuperación solicitados lo permiten; una etiqueta de límite del agente es evidencia de atribución, no una forma de eludir la autorización.

```text
recall_context({
  query: "deployment adapter decision, Codex fix, and handoff status",
  max_items: 6,
  max_tokens: 1200
})
# Inspect the returned context and boundary summary before continuing.
```