Search atomic Claims across Agents, snapshots, and mechanisms. Source, official documentation, reproduced evidence, and inference always keep distinct labels.
Claude Code's official Agent Teams documentation describes experimental lead-and-teammate coordination with independent context windows, a shared task list, direct messaging, and no automatic worktree isolation.
How agent teams work, comparison with subagents, enablement, and limitationsClaude Code's official documentation separates permission rules, which decide tool and resource access, from OS-level sandbox enforcement for Bash filesystem and network access, and recommends using both as defense in depth.
Permission rule syntax; How permissions interact with sandboxingClaude Code's official hook contract exposes lifecycle events including pre- and post-tool use, permission requests, session start/end, and stop; PreToolUse hooks can deny a call before normal permission-mode checks, while allow decisions cannot override stricter deny rules.
PreToolUse; Hook events; Hooks and permission modesClaude Code's official documentation describes subagents with separate context windows, configurable prompts, tools, models, permissions, hooks, skills, depth and turn limits, and optional temporary Git worktree isolation.
Configure subagents; Control capabilities; Work with subagents; worktree isolationOfficial Codex CLI documentation presents one terminal loop for exploring code, planning changes, editing files, running local tools, steering an active turn, and continuing follow-up work in the same session.
Work against your local repository; Keep the coding loop in your terminalAt the pinned Codex source revision, run_turn repeatedly samples the model, executes requested function calls, feeds results into later samples, accepts steering input, and stops when follow-up work is no longer required or a stop/error path wins.
run_turnAt the pinned Codex source revision, run_turn repeatedly samples the model, executes requested function calls, feeds results into later samples, accepts steering input, and stops when follow-up work is no longer required or a stop/error path wins.
RegularTask::runThe pinned Codex App Server accepts JSON-RPC requests and notifications over selectable stdio, Unix-socket, or WebSocket transports and dispatches typed requests through dedicated processors.
AppServerTransport startup and JSONRPCMessage dispatchThe pinned Codex App Server accepts JSON-RPC requests and notifications over selectable stdio, Unix-socket, or WebSocket transports and dispatches typed requests through dedicated processors.
process_request and typed request processorsThe pinned Codex turn loop checks context limits before and after sampling and can replace history through local or remote compaction before resuming the same turn.
run_pre_sampling_compact; run_auto_compactThe pinned Codex turn loop checks context limits before and after sampling and can replace history through local or remote compaction before resuming the same turn.
run_compact_task_inner_impl; build_compacted_historyThe pinned Codex protocol defines typed events for turn lifecycle, streamed content, tools, approvals, compaction, hooks, and collaborative-agent activity, and the turn implementation emits those events through the session boundary.
EventMsgThe pinned Codex protocol defines typed events for turn lifecycle, streamed content, tools, approvals, compaction, hooks, and collaborative-agent activity, and the turn implementation emits those events through the session boundary.
send_event and emit_turn_item lifecycle callsThe pinned Codex core models approval decisions separately from sandbox transformation, with policy-dependent outcomes that can forbid, request approval for, skip approval for, or sandbox a tool attempt.
ApprovalAction; approval precedence and resolutionThe pinned Codex core models approval decisions separately from sandbox transformation, with policy-dependent outcomes that can forbid, request approval for, skip approval for, or sandbox a tool attempt.
ExecApprovalRequirement; SandboxAttempt; ToolRuntimeAt the pinned revision, Codex assembles selected skills and plugins into turn context and runs typed lifecycle hooks around session start, tool use, permissions, stop, compaction, and session end.
build_skills_and_plugins and hook callsAt the pinned revision, Codex assembles selected skills and plugins into turn context and runs typed lifecycle hooks around session start, tool use, permissions, stop, compaction, and session end.
run_*_hooks functionsThe pinned Codex core registers multi-agent tools for spawning and communicating with child agents and implements spawn through a dedicated agent-control boundary rather than inside the main sampling loop.
spawn tool handlerThe pinned Codex core registers multi-agent tools for spawning and communicating with child agents and implements spawn through a dedicated agent-control boundary rather than inside the main sampling loop.
child agent spawn controlThe pinned Codex core separates model-visible tool specifications in ToolRouter from runtime registration and collision handling in ToolRegistry, then resolves each parsed call to its registered runtime.
ToolRouterThe pinned Codex core separates model-visible tool specifications in ToolRouter from runtime registration and collision handling in ToolRegistry, then resolves each parsed call to its registered runtime.
ToolRegistry registration and lookupGrok Build's pinned ACP library implements line-oriented JSON-RPC transport and normalization, and the shell projects Agent activity into ACP session updates for editor or process clients.
ACP channel, message, normalization, and line-reader modulesGrok Build's pinned session actor multiplexes commands and asynchronous events, explicitly starts turns, streams sampler output, dispatches tool calls, and emits lifecycle updates through completion, failure, or cancellation.
session actor run loop and turn event dispatchGrok Build's pinned Agent uses a configurable compaction policy with context thresholds, optional model and memory-flush settings, wall-clock limits, and an optional two-pass mode.
CompactionPolicy and builder methodsGrok Build's pinned Agent uses a configurable compaction policy with context thresholds, optional model and memory-flush settings, wall-clock limits, and an optional two-pass mode.
should_auto_compact and context thresholdGrok Build's pinned file-event utilities write versioned session events as append-oriented JSONL, and the tracker emits typed turn, tool, permission, and terminal lifecycle records.
JSONL event writerGrok Build's pinned file-event utilities write versioned session events as append-oriented JSONL, and the tracker emits typed turn, tool, permission, and terminal lifecycle records.
turn, tool, permission, and terminal event emissionGrok Build's pinned source separates semantic allow/ask/deny policy from OS sandbox activation; the manager exposes requested and active state, uses supported platform backends, and may explicitly continue unsandboxed when unsupported or application fails.
permission decision resolution and deny precedenceGrok Build's pinned source separates semantic allow/ask/deny policy from OS sandbox activation; the manager exposes requested and active state, uses supported platform backends, and may explicitly continue unsandboxed when unsupported or application fails.
SandboxManager state and apply fallbackGrok Build's pinned extension surface includes plugins, prompt skills, MCP tools, and lifecycle hooks, with pre-tool gates able to modify or block operations.
session, tool, prompt, and subagent hook event typesGrok Build's pinned extension surface includes plugins, prompt skills, MCP tools, and lifecycle hooks, with pre-tool gates able to modify or block operations.
pre-tool gate and post-event dispatchGrok Build's pinned sampler retry module produces explicit decisions for rate limits, transient failures, context limits, image fallback, and client rebuilds, using retry-after or exponential jitter while leaving fatal outcomes non-retryable.
RetryDecision and error classificationGrok Build's pinned source resolves named subagents and resume identity, while task execution uses separate child session identity and explicit isolation or worktree metadata rather than an inline prompt macro.
definition, context, override, and resume modulesGrok Build's pinned source resolves named subagents and resume identity, while task execution uses separate child session identity and explicit isolation or worktree metadata rather than an inline prompt macro.
child session launch and isolation metadataGrok Build's pinned ToolBridge owns a finalized registry, exposes model-facing definitions, supports built-in and MCP-backed registrations, and routes calls through typed registry dispatch.
ToolBridge registry construction, definitions, and callOpenCode's pinned session prompt service repeatedly handles pending subtasks and compaction, resolves the active Agent and tools, invokes the model processor, and stops only at an explicit terminal condition.
Prompt service run loop around the while(true) message processorOpenCode's pinned source exposes a headless HTTP server, while the terminal UI can use an embedded worker and RPC-forward global server events rather than owning a separate Agent core.
HTTP application and event routesOpenCode's pinned source exposes a headless HTTP server, while the terminal UI can use an embedded worker and RPC-forward global server events rather than owning a separate Agent core.
embedded fetch and global event forwardingOpenCode's pinned compaction service measures context pressure, constructs a summary turn, preserves recent context, and separately truncates oversized historical tool output.
overflow checks, compaction task, and tool-output pruningOpenCode's pinned event bridge enriches events with location and aggregate identity, assigns version and sequence metadata for durable records, and forwards public events through the global bus.
publish and durable event append pathOpenCode's pinned permission service uses last-match wildcard rules, defaults unresolved requests to ask, and represents deny, one-time approval, persistent approval, and rejection explicitly.
evaluate, ask, reply, and ruleset mergeOpenCode's pinned source discovers local skills, loads configured plugins, and imports MCP tools into the common tool-resolution boundary, with trust and permission still configuration-dependent.
configured and bundled plugin loadingOpenCode's pinned source discovers local skills, loads configured plugins, and imports MCP tools into the common tool-resolution boundary, with trust and permission still configuration-dependent.
stdio, HTTP, and SSE MCP connections and tool importOpenCode's pinned source discovers local skills, loads configured plugins, and imports MCP tools into the common tool-resolution boundary, with trust and permission still configuration-dependent.
skill directories and SKILL.md discoveryOpenCode's pinned retry policy classifies provider and HTTP failures, honors retry-after metadata, applies bounded exponential delay, and excludes non-retryable failures such as context overflow.
retryable, retry-after parsing, and schedule constructionOpenCode's pinned task tool limits nesting, derives child permissions, creates parent-linked child sessions, and supports foreground or background tasks with explicit metadata.
ancestry depth check, child permission derivation, and Session.createOpenCode's pinned tool registry combines built-in, custom, plugin, and MCP definitions, permission-filters visibility, validates arguments, and dispatches registered handlers with normalized output metadata.
Registry service, resolve, and tool execute wrappersPi's pinned agent core uses an inner loop for model/tool/steering turns and an outer loop for queued follow-up messages, emitting explicit agent, turn, message, and tool lifecycle events throughout.
runLoopPi's pinned agent core uses an inner loop for model/tool/steering turns and an outer loop for queued follow-up messages, emitting explicit agent, turn, message, and tool lifecycle events throughout.
Agent and PendingMessageQueuePi triggers compaction against a configurable reserve threshold, summarizes the older branch, keeps recent entries, tracks file operations, and preserves the full append-only session history outside the reduced model context.
CompactionSettings; shouldCompact; compactPi triggers compaction against a configurable reserve threshold, summarizes the older branch, keeps recent entries, tracks file operations, and preserves the full append-only session history outside the reduced model context.
SessionManager; appendCompaction; buildContextEntriesPi explicitly does not provide an in-process permission system or built-in sandbox for model-invoked filesystem, process, network, or credential access; isolation must come from a container, VM, micro-VM, or other operating-system boundary.
SecurityPi explicitly does not provide an in-process permission system or built-in sandbox for model-invoked filesystem, process, network, or credential access; isolation must come from a container, VM, micro-VM, or other operating-system boundary.
Project trust; No built-in sandbox; Recommended isolationPi's coding-agent layer uses an extension runner to dispatch lifecycle events and lets extensions add or replace tools, commands, UI, providers, context transforms, and compaction behavior without modifying the low-level agent loop.
ExtensionRunnerPi's coding-agent layer uses an extension runner to dispatch lifecycle events and lets extensions add or replace tools, commands, UI, providers, context transforms, and compaction behavior without modifying the low-level agent loop.
Extensions; What Pi intentionally omitsPi intentionally omits a built-in subagent orchestration policy; its official project guidance points users to separate Pi processes or extensions so delegation semantics remain outside the minimal core.
What Pi intentionally omits — No sub-agentsPi RPC mode accepts typed commands as LF-delimited JSON on stdin and emits responses plus agent events as LF-delimited JSON on stdout, including controls for prompting, steering, sessions, compaction, retry, models, and tools.
RpcCommand; RpcResponse; RPC eventsPi RPC mode accepts typed commands as LF-delimited JSON on stdin and emits responses plus agent events as LF-delimited JSON on stdout, including controls for prompting, steering, sessions, compaction, retry, models, and tools.
RPC command dispatch and JSONL outputPi combines a live typed AgentEvent stream with an append-only JSONL session tree whose entries carry id and parentId, allowing the active context to move between branches without deleting prior history.
agentLoop and runLoop event emissionPi combines a live typed AgentEvent stream with an append-only JSONL session tree whose entries carry id and parentId, allowing the active context to move between branches without deleting prior history.
SessionEntryBase; SessionManager; getTree; branchPi validates tool arguments, offers before- and after-tool interception points, and executes a batch sequentially or in parallel according to the configured strategy and individual tool constraints.
executeToolCalls; executeToolCallReasonix ACP uses an NDJSON JSON-RPC 2.0 connection over stdin/stdout, runs requests and notifications concurrently, maps engine events to session updates, and forwards gated tool decisions as client permission requests.
Conn; Serve; JSON-RPC framingReasonix ACP uses an NDJSON JSON-RPC 2.0 connection over stdin/stdout, runs requests and notifications concurrently, maps engine events to session updates, and forwards gated tool decisions as client permission requests.
updateSink; requestPermissionThe pinned Reasonix engine runs a bounded tool-round loop that captures a cache prefix shape, streams a provider turn, commits only a clean terminal attempt, then either finalizes or dispatches the committed tool calls before the next round.
runToolLoopReasonix treats compaction as a low-frequency cache-reset point, uses multiple context thresholds and a recent-tail budget, and records prefix-shape diagnostics that distinguish system, tool-schema, and content-rewrite changes.
compaction thresholds and projectionReasonix treats compaction as a low-frequency cache-reset point, uses multiple context thresholds and a recent-tail budget, and records prefix-shape diagnostics that distinguish system, tool-schema, and content-rewrite changes.
PrefixShape; CaptureShape; CompareShapeReasonix designates an append-only events JSONL file as transcript authority and keeps derived context, event-index, display-index, conflict, checkpoint, and job artifacts in separate sidecars.
SessionEventLog and session sidecarsReasonix designates an append-only events JSONL file as transcript authority and keeps derived context, event-index, display-index, conflict, checkpoint, and job artifacts in separate sidecars.
native event append and projectionReasonix separates permission and approval posture from OS-level shell confinement: approval modes preserve explicit deny and fresh-decision rules, while an enforced but unavailable shell sandbox fails closed instead of running unwrapped.
approvalManager; BuildHeadlessApprovalGateReasonix separates permission and approval posture from OS-level shell confinement: approval modes preserve explicit deny and fresh-decision rules, while an enforced but unavailable shell sandbox fails closed instead of running unwrapped.
package contract; Spec; UnavailableMessageReasonix plugin manifests can contribute hooks and MCP servers, while lazy MCP placeholders keep cached tool metadata stable and defer process startup or live schema reconciliation until needed.
Manifest contributions, hooks, and MCP serversReasonix plugin manifests can contribute hooks and MCP servers, while lazy MCP placeholders keep cached tool metadata stable and defer process startup or live schema reconciliation until needed.
lazyTool; LazyToolset; schema cache reconciliationReasonix replays one frozen sampling payload across bounded stream-recovery attempts, commits only the selected clean attempt, and separately breaks repeated identical write-like failures after a small threshold unless a safe state recheck clears the signature.
streamWithSamplingRecoveryReasonix replays one frozen sampling payload across bounded stream-recovery attempts, commits only the selected clean attempt, and separately breaks repeated identical write-like failures after a small threshold unless a safe state recheck clears the signature.
repeat failure threshold, signatures, and state recheckReasonix constructs a filtered child tool registry, supports a read-only child profile, caps recursive delegation by depth, hides parent-only orchestration and job tools, and gives each child a private temporary-session boundary.
withSubagentSessionTemp; SubagentToolRegistryForDepth; read-only profileReasonix separates batch scheduling from single-call execution, so concurrency decisions, per-call context, capability gates, tool invocation, results, and failure bookkeeping cross explicit boundaries.
executeBatchReasonix separates batch scheduling from single-call execution, so concurrency decisions, per-call context, capability gates, tool invocation, results, and failure bookkeeping cross explicit boundaries.
executeOneIn the controlled reference experiment, the project harness validates and executes one declared read_file call, records the successful result between two model turns, and produces the same normalized trace fingerprint across two repetitions.