Make complex systems readable by path

Follow two read-only Inspect tools, plugin_manager, and persistent Bundles to distinguish profile writes, Host activation, and browser verification.

Follow spawn/fork, sendMessage, resident capacity, PTC workflows, Ralph, and Team to separate acceptance, completion, and cleanup.

Follow text pruning, image offload, and summary replacement to reconstruct requests from system messages, request/header, and cache prefixes.

Trace tool/call, durability checkpoints, approval, sandboxing, JSONL, and crash repair to separate intent, permission, confinement, and unknown outcomes.

Trace four message types, stream settlement, replayable projections, and the v3 restoration boundary across model and human views.

Read patch composition, Context, Service, isolation, Fiber lifecycle, and HMR as one replaceable runtime with ordered ownership.

Connect Profile, Bundle, Cordis, ReactLoopAgent, SessionEvent, and Web/ACP into one route before opening projection, side-effect, and recovery boundaries.

Find recurring failures across several runs, let the coding agent revise skill.md, and rerun the same validation before keeping the change; then inspect which HarnessOpt steps are still disconnected.

Separate heartbeats, scheduled work, and background tasks; see how schedules are stored, duplicate delivery is avoided, and interrupted work resumes after a restart.

Separate configured Agents, native subagents, and ACP harnesses; see which context and tools a child receives and how its result returns to the parent task.

See which tools are exposed, where commands run, which operations need user approval, and when elevated execution may leave the sandbox.

See how OpenClaw discovers tools, loads Skills and plugins, filters what is available, validates arguments, and runs hooks before and after each call.

Trace workspace bootstrap, the system prompt, and ContextEngine into transcript, memory, pruning, and compaction to see what the model really receives.

See how a message selects an Agent and session, then compare how steer, followup, collect, and interrupt queue or stop current work.

Separate operator, node, and restricted worker entry paths, then follow handshakes, authorization, and event delivery to see why gaps require a fresh state read.

Follow one message from ChannelPlugin, sessionKey, and queueing into the embedded agent, then through tool events, completion state, and the final reply.

Compare ActAdd and CAA intervention positions, separating inference-time steering, reflection training, and independent audits with their validation and rollback conditions.

Trace persona extraction, the Assistant axis, and one-sided capping to see how post-training stabilizes roles and where self-model evidence stops.

Compare CoT, NLA, SAE, and J-lens evidence, then trace continuous thought through Coconut.

Separate J-lens readouts, sparse reconstruction, and causal intervention through the reference implementation.

Follow one file change through model computation, a proposed tool call, and runtime execution, separating activations, KV caching, and durable records.

Separate toolchains, language versions, and compatibility defaults with a Go 1.22 loop experiment, then trace timers, container scheduling, GC, and upgrades.

Trace Transport.getConn, persistConn, bodyEOFSignal, and HTTP/2 stream/flow control, then combine httptrace, metrics, pprof, execution trace, and race.

Trace compiler escape graphs, slice backing arrays, mallocgc, each P's mcache, concurrent GC, write barriers, and mark assists to separate allocation rate from live heap.

Trace cancelCtx, causes, timers, AfterFunc, WithoutCancel, request contexts, and Server.Shutdown to separate signals, cleanup, and joining.

Trace the two interface words, getitab/itabInit, convT, gc shapes and dictionaries, and reflect.Value to separate three kinds of retained type information.

Follow hchan, chansend/chanrecv, sudog, selectgo, Mutex, and runtime semaphores through communication, backpressure, and critical sections.

Follow go h.fetch through newproc, local/global run queues, findRunnable, work stealing, preemption, and runnable latency.

Use the URL slice, result channel, and JSON collector to trace value copies, aliases, append growth, interfaces, and range variables through the spec and runtime.

Follow a concurrent fetch request from Server.Serve, request context, and Transport into internal/poll, netpoll, and a runnable goroutine.

Start with one repeatable task, then add outcome, process, safety, and operations checks.

A run ends; learn how the task preserves progress, recovers, verifies, and starts another run.

Follow repeated rounds of reading, editing, testing, and deciding inside one run.

See how “run the tests” passes through tools, permission, isolation, execution, and records.

Distinguish the library, retrieved candidates, and the material the model can actually see now.

Start with a vague request and add the goal, background, constraints, done criteria, and output.

Follow a payment-test task and use Codex source to separate request acceptance, run termination, and verification.

Follow manifests, stage directors, checkpoints, render locks, and final review, separating Agent instructions, code-enforced checks, and project-file recovery from automatic execution resumption.

Follow an AI music video through Workflows, Activities, Event History, replay, heartbeats, and external idempotency boundaries.

Separate Temporal's job identity and event history from OpenMontage's creative stages, artifacts, and human approval before entering both source readings.

Compare what Mem0, Letta, Graphiti, LangMem, TencentDB, OpenViking, Cognee, and Supermemory store, when they write, and how they retrieve before entering each source reading.

Follow online review and Skill publication separately from GEPA offline optimization and SkillCraft benchmarks, distinguishing candidate edits, validation evidence, and adoption.

Follow one environment fact through delta, extraction, reconciliation, Fact/Episode storage, and hybrid retrieval, then test quality, cost, and refusal regressions on LoCoMo-10.

Follow one request through Runner, Agent, Model, and services, then see when Summary, Context Compaction, and Session Recall compress, rebuild, and recover original events.

See how Component, Runnable, and compose Graph compile into executable Go, then follow checkpointing, callbacks, ADK Runner, ChatModelAgent, and AgentTool.

Read Agent, Task, Crew, Process, and Flow source to see how CrewAI separates team autonomy from production control.

AutoGen is now in maintenance mode. Read from Core runtime and AgentChat teams to MAF Agent, Workflow, Orchestrations, and Hosting.

See how AgentOS registers Agents, Teams, and Workflows, exposes run APIs and storage, and connects approvals, RBAC, scheduling, and external interfaces to the same service.

See how one ADK 2.0 Runner executes autonomous Agents and deterministic Workflows, records progress as Session Events, and exposes long-running work through the Task API.

Use one contract-renewal task to identify which endpoints MCP, A2A, AG-UI, Agent Client Protocol, and model Provider APIs connect, what they carry, and what they cannot replace.

Use one scripting task to separate Coding / General from Local / Cloud, then see where workspace, sandbox, session, artifact, and memory live—and which survive sandbox deletion.

Expand Pi's minimal baseline by following how AgentScope emits events, records state, approves tools, and adapts OpenAI Responses differently from Chat Completions.

Follow pi-ai, agent-core, and coding-agent to see how a minimal implementation runs the tool loop, stores the session tree, and compacts context while leaving plans, sub-agents, MCP, and permission policy to extensions.

Use the Claude Code and Codex execution paths as a reference, then compare which components call models, execute tools, store state, and check permissions.

Read how paper mem0, mem0g, and mem0 v3 move from mutable memories to ADD-only writes, entity linking, and multi-signal retrieval.

Separate archived V1 Block and AgentState recovery from the current Letta Code local backend, which compiles Git-committed memory for later turns.

Read how episodes, EntityEdge, valid_at / invalid_at, and hybrid retrieval keep facts current without deleting history.

Read how manage_memory, BaseStore, checkpointer, and background manager split memory across execution paths.

Read Context Offload, L0-L3, Gateway, Memory Hub, and Memory Proxy as team assets enter agent context.

Follow one coding-agent task through viking://, L0/L1/L2, find/search, and two-phase session commit, then see which material reaches the next model request.

Compare Cognee's add / cognify / recall pipeline with Supermemory's add / profile / search / connectors to see how multiple Agents share writes, retrieval, and user profiles.

Build the source-reading route first: CLI, REPL, queue, query loop, model calls, tool execution, transcript, and resume.

Trace CLAUDE.md and memory files through cached reads, invalidation, reloads, and distinct request paths; a file write does not guarantee an immediate request update.

Separate stable, context, volatile, and turn-only input, then decide where facts, evidence, procedures, and temporary state should be stored.

Follow finalizer, constrained background review, and independent Curator cycles to distinguish candidate proposals, applied writes, and state visible to later turns.

Trace source reading, normalization, writing, relationship updates, and later loading to see what explicit learning actually changes.

Start with task records, rubrics, and data sources, then build a fair measuring stick before optimizing any Skill.

Make a Skill editable by the optimizer, follow execution, feedback, revision, and reruns, then confirm which Self-Evolution steps are actually connected.

Inspect project commands, hermes verify, and opt-in evidence recording. Turn-end checks are off by default and provide bounded nudges when enabled; delivery still depends on actual results.

Separate memory, transcript, compact, microcompact, and the exact content sent to the model instead of calling everything context.

Read the path from model tool_use to validated local work and paired tool_result.

Follow allow, deny, ask, hooks, permission requests, and denied tool results through the tool path.

Read how slash commands, skills, plugins, MCP prompts, and MCP tools enter the current command table and tool pool.

Compare normal subagents with fork paths, worker tool scope, cache-stable prefixes, and context isolation.

Place hooks back into the turn lifecycle: prompt, tool, stop, compact, session, and subagent boundaries.

Separate UI messages, durable transcript, API view, content replacement, and restored runtime state.

Tie cache_control, stable prefixes, fork suffixes, microcompact, replacement state, and cache-break detection into one performance story.

Follow one request through sessions, step context, optional tool calls, client notifications, and durable recovery records.

See how history and StepContext are prepared separately, with for_prompt, WorldState updates, and compaction shaping the next model input.

Distinguish starting or steering a turn, input acceptance and completion, and live notifications from filtered durable records.

Follow tool registration and routing into UnifiedExec, separating call results, still-running processes, and output returned to the model.

See how approval policy, centralized review, and SandboxAttempt govern execution, rejection, and controlled retries after sandbox denial.

Trace events through core, app-server, and clients, separating streamed views, approval requests, and turn/item reconstruction from rollout.

Separate skill instructions, plugin resources, MCP tool exposure, and child tasks as they enter the current step.

Follow the separate triggers for prompt, tool, permission, compaction, stop, interrupt, and session-end hooks.

Separate reusable prefixes, cache accounting, and WebSocket continuation across model-specific cache contracts and Responses / Lite request shapes.

Follow JSONL writes, reverse scanning, and tail replay to understand session recovery, forks, and compatibility with old rollback records.

Follow initialization, thread and turn requests into app-server, distinguishing subscriptions, accepted input, and completed work.

Follow two background stages through separate v1/v2 memories, polluted-source removal, and selective reuse in later requests.

See how restricted accounts, tokens, ACLs, network rules, and service ownership checks constrain Windows command execution.

Follow one message to finalizer: see how the model and tools hand work back and forth, how records are stored and recovered, and how useful lessons remain available later.