Make complex systems readable by path

Separate heartbeat, automations, background tasks, and restart recovery; trace durable schedules, task ledgers, idempotent delivery, and bounded replay.

Separate configured Agents, native subagents, and ACP harnesses; trace child identity, context, tool authority, completion flow, and thread binding.

Separate capability visibility, execution environment, concrete command consent, and exec host escape, then see how trusted sender and host-local policy narrow them.

Trace the candidate pool, skill snapshots, and plugin contracts through layered policy, schema projection, and typed hook checkpoints around every call.

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

Separate bindings, dmScope, identityLinks, sessionKey/sessionId, and the steer, followup, collect, and interrupt temporal contracts.

Read connect, hello-ok, method descriptors, operator/node identity, event fanout, gap refresh, and slow-consumer boundaries.

Trace ChannelPlugin, sessionKey, queues, and the embedded agent through tool events, lifecycle termination, and ReplyPayload—the runtime coordinates for the eight-part series.

Start with J-space and silent reasoning; compare CoT, NLA, SAEs, personas, and activation steering; then reconnect the mechanisms to memory, self-evolution, and agent alignment.

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 one task from request to verified result, then name the six engineering problems along the way.

Follow pipeline manifests, stage directors, checkpoints, ToolRegistry, render locks, and final review from prompt to a resumable, accepted production.

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

Put Mem0, Letta, Graphiti, LangMem, TencentDB, OpenViking, Cognee, and Supermemory on one map before reading each system in depth.

Use Claude Code and Codex as a reference point, establish a runtime baseline with Pi and AgentScope, separate local and cloud worksites, then read MCP, A2A, AG-UI, and ACP before comparing ADK, Agno, AutoGen, CrewAI, Eino, and tRPC-Agent-Go.

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

Read how memory_blocks, AgentState, Memory.compile, and MemFS put long-term memory inside the agent's own state boundary.

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, refs/jsonl/MMD task canvases, and the L0-L3 pipeline that keeps tool logs recoverable.

Follow one coding-agent task through viking://, L0/L1/L2, find/search, two-phase session commit, and the model-view boundary.

Read Cognee's add / cognify / recall pipeline beside Supermemory's add / profile / search / connectors contract.

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

Trace CLAUDE.md, auto memory, session memory, and user context projection into the next request and prompt-cache prefix.

Separate stable, context, volatile, and turn-only input, then return facts, evidence, procedures, and temporary state to the right owner.

Follow finalizer, background review, nudge, and the two-stage Curator through the runtime path that prepares experience for future 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.

Expose a Skill as optimizable instructions, follow execution, feedback, reflection, and reruns, then audit the Self-Evolution prototype's real boundary.

Connect project facts, the evidence ledger, hermes verify, and the finish gate so delivery claims follow fresh passing evidence.

Separate memory, transcript, compact, microcompact, and model-visible projection 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.

A source-guided route through entry, typed protocol, session, turn, context, model stream, tool authority, and evidence projection.

A source-guided walkthrough of durable history, prompt projection, context diffs, compaction replacement, and rollout recovery.

A source-guided route through TurnStartParams, Submission, Op, EventMsg, app-server v2 projection, and rollout recovery.

Follow ToolSpec, ToolRouter, ToolRegistry, ToolInvocation, hooks, approval, sandboxing, events, and tool output recording.

Follow turn policy, permission hooks, ToolOrchestrator, SandboxAttempt, and sandbox-denied retry to see how side effects are gated.

Follow EventMsg, TurnItem, ThreadItem, ServerNotification, TUI history cells, rollout, and resume to see how clients observe one fact stream.

Follow skills, plugins, MCP tool exposure, tool_search, dynamic tools, and AgentControl as extra capability joins one turn.

Follow HookEventName, hook discovery, prompt gates, tool gates, compaction, and Stop as hooks rejoin the turn runtime.

Follow OpenAI prompt caching, stable prefixes, dynamic tails, prompt_cache_key, compaction, and token usage metrics to see how Codex shapes perceived speed.

Follow RolloutItem, the JSONL writer, InitialHistory, reverse scan, replay suffix, rollback markers, and fork snapshots to see how Codex makes a thread recoverable.

Follow app-server initialization, typed ClientRequest, thread/start, turn/start, listener projection, and the Python / TypeScript SDKs to see how external clients enter Codex.

Follow Feature::MemoryTool, memory_mode, Phase 1 / Phase 2, the memories workspace, read path, citation, and polluted threads as one local recall layer.

Follow the OpenAI engineering post and openai/codex source to see how sandbox users, ACLs, firewall rules, command runner, and restricted tokens turn runtime authority into local OS boundaries.

Follow one message through finalizer and recoverable delivery, then map Memory, SessionDB, Skills, background review, and multiple runtime entrances.