Research Vault

A book-length analysis ('Orange Book') dissecting Anthropic's AI engineering decisions from the 510,000 lines / 1,902 TypeScript files that shipped inside an npm package. Chapters cover the agent loop, context compaction, the hook system, and sub-agents - the concepts, not just the code.

Smaller independent study of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

A ~330-file markdown analysis of the leaked source (512,000+ lines, 1,906 files, TypeScript on Bun), organized module by module from the March 31, 2026 npm source-map leak. Its granularity makes it the best reference for looking up a specific subsystem.

Follows a dispatched agent through its full lifecycle - foreground vs background execution, auto-backgrounding of long tasks, sidechain transcripts for resume, layered tool filtering, and result handoff - then catalogs six reusable orchestration patterns: worker pool, pipeline, supervisor-worker, adversarial verification, fork-join, and resume chain. The adversarial verification agent, which must run real commands and issue a PASS/FAIL verdict while being forbidden from editing the project, gets special attention as a defense against LLM self-verification failure modes.

Walks the layered validation pipeline that backs up the prompt when the model ignores its 'suggestions': control-character checks, multi-view quote extraction, obfuscated-flag detection (ANSI-C quoting, empty-quote concatenation, quote chains, triple quotes), brace-expansion and backslash-escaped-operator traps, hard path constraints, a whitelist-plus-denylist sed validator, and per-tool exit-code semantics. Every validator returns allow/ask/deny/passthrough, and misparsing-class findings outrank informational ones.

Argues that because LLMs are probabilistic, prompts alone are gambling and code alone wastes the model's flexibility. Maps how Claude Code pairs every soft prompt rule ('use Edit instead of sed', 'NEVER force-push') with an independent deterministic check (sed validators, destructive-git detection, sandbox gates), analyzes the four failure combinations of the two layers, and distills five reusable design principles for any tool-calling agent system.

Source-level analysis of the three ways Claude Code dispatches work: Spawn (a named sub-agent with a fresh context, its own tool pool, permission mode, and model), Fork (a synthetic agent that inherits the parent conversation byte-for-byte so parallel workers share the prompt cache), and Direct (the main agent just does the task itself). Covers sync-to-background promotion via a promise race, recursion guards on forking, git-worktree isolation, and a decision matrix for picking a strategy per task.

Dissects how BashTool's prompt forms the first line of defense: a three-layer structure (tool preference chains, usage constraints, git-safety and sandbox protocols) assembled dynamically per environment. Shows how wording strategy works - capitalized NOT, positive alternatives ('use Edit' rather than 'avoid sed'), and 'better user experience' framing instead of 'security' - and how token budget (config dedup, conditional blocks) is treated as a first-class engineering constraint rather than an afterthought.

An interactive, fully static, bilingual (EN/ZH) documentation site covering Claude Code CLI internals, built from source analysis of v2.1.88 (live at cc.clawlabz.xyz). Turns the raw analyses into navigable technical documentation pages per subsystem.

A React/TypeScript/Vite slide-deck application presenting the Claude Code architecture analysis: the leak event timeline, architecture design, and safety mechanisms. The presentation format makes it ideal for quick summary-level orientation before diving into the deeper analyses.

A second book-length Chinese treatment of Claude Code's source ('Understanding Claude Code In Depth') with a compiled PDF and LaTeX sources. Focuses on turning the complex system into reusable engineering knowledge: source structure, runtime mechanics, permissions and extension points, security and context strategy.

A documentation-only collection of 20 independent research reports on Claude Code v2.1.88 covering architecture, agent behavior, permission design, prompt assembly, MCP integration, and context management. Deliberately ships analysis rather than extracted code.

Tracks how Claude Code changed version over version and ports the strongest architecture, prompt-engineering, and skill-system ideas into the OpenClaw platform (analysis scale: 1,903 files, ~512k lines). The best single source for 'what the leading harness added over time' insights.

Smaller independent analysis of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

Smaller independent analysis of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

One of several smaller independent analyses of the Claude Code source; worth skimming for observations not present in the larger bundles.

Smaller independent analysis of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

Smaller independent analysis of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

unavailable - original vault name: diagrammatical-ogalala16/claude-code-source-analysis (404 at fetch time; repo removed or renamed).

Smaller independent analysis of the Claude Code source; skimmed for unique observations to cross-check the major bundles.

A systems-engineering reconstruction of the complete Claude Code agent harness from a reverse-engineered v2.1.88 snapshot (includes the extracted source zip plus appendix analyses). Part of a series that also covers OpenAI Codex CLI internals, giving a comparative harness view.

A full deobfuscated source map of the Claude Code npm bundle reconstructed from the published package's source maps - the largest single research artifact in this corpus (~160MB of mapped source). Its directory structure serves as the canonical map of Claude Code's internal modules.

An independent, earlier source-map extraction of Claude Code (v0.2.8 research preview) capturing the agent's terminal-native design: codebase understanding, file edits, git workflows through natural language. Useful as a second witness when the SatoMini map is ambiguous, and for seeing how early the core loop stabilized.

Packages a deep source-level analysis of a Claude Code snapshot (~1,900 files) with HTML reports, architecture visuals, and walkthrough guides, plus an independently written source-analysis report in Chinese and English. One of the most complete single bundles for studying the tool definitions, main agent loop, and edit-validation path.

A full book on harness engineering ('from Claude Code source code to AI coding') with Chinese and English editions in book/ and book-en/. The single best conceptual source in this corpus: chapters on prompt assembly, tool design, context management, verification loops, and sub-agent patterns.

A distilled 'skill' file of agentic harness patterns - short, dense, and directly reusable as workflow steps. The compressed counterpart to the harness-engineering book.

A comparative research repository on AI coding agents, full-source scanning, spec-driven development, and LLM wiki/RAG trends, with analysis reports, category READMEs, CSV tables, and a data/source-inventory.json cataloging the analyzed agents. Useful as the index that cross-references the Tier 4 agents.

Production patterns for building AI agent memory systems, distilled from operating a real multi-tenant system (154K+ observations, 3-node cluster) that competes with commercial offerings like Mem0 and Zep - architectural patterns and lessons, not a tutorial.

A field guide that maps AI-agent memory systems for humans and agents alike: structured source records, taxonomy axes, tags, confidence scores, provenance, and verification hints - an atlas rather than another paper list.

A panoramic survey (2026.03) of 30+ agent memory projects across 15 dimensions - standalone memory frameworks plus agents' built-in memory - including LongMemEval scores. Notably documents the trend of agentic/observational memory overtaking pure vector memory.

A personal AI memory system for agents featuring an evolving personality layer (six traits) alongside memory - an example of memory systems extending into persona and preference modeling.

A production-oriented dual-store agent memory system: separate tables for memories, core files, and skills in a multi-table vector store, with configurable confidence thresholds and trigger-word driven self-evolution.

An npm-published long-term memory system for AI agents promising 'never lose context again' - a representative of the packaged, drop-in memory layer approach.

An agent memory system that auto-extracts insights from coding sessions, recalls relevant memories in future conversations, and builds a growing reusable knowledge base - aimed squarely at not repeating the same mistakes across sessions.

An AI agent memory validation platform that continuously verifies whether facts stored in agent memory are still true - guarding writes and re-validating stored knowledge instead of trusting it forever.

An intelligent memory management system designed for medical AI scenarios - a domain-specialized memory design where accuracy and traceability requirements are unusually strict.

Observability and debugging for AI agent memory: instruments the memory pipeline (write, read, compress, update) to show exactly why an agent 'forgot' something. pip-installable with framework integrations.

A lightweight memory ingestion pipeline that processes JSON memory logs through summarization and deduplication, then fans out to three backends: a vector DB (Qdrant), a relational timeline (DuckDB), and a memory graph (Neo4j).

An agent memory system built on a skill + memory index architecture following a radical-minimalism principle ('jsonl, md, at most sqlite'), with a dual-repo split: open framework, private data.

A production-grade AI agent memory system in Rust featuring intelligent memory management, knowledge graphs, and temporal tracking - a reference for what a serious, performance-focused memory engine looks like.

Representative of a cluster of small demo/student implementations all named 'ai-agent-memory-system' (by users Sant2121, SATHISH28062004, trose, prakoso-id, framsouza, vicpat, plastininmixail-ai; three others in the original corpus are now 404). Together they show the common baseline shape: a store, an embedder, a recall call, and a summarizer.

Long-term memory for agents with hybrid search, reranking, and explicit 'compaction protection': preserving what matters when the context window fills and compaction wipes raw conversation detail.

A neuroscience-inspired persistent memory system with three storage layers (working/long-term/archive), hybrid retrieval, automatic decay, and memory consolidation.

Local-first hybrid semantic search backed by authoritative SQLite state plus a vector sidecar: facts, chunked documents, conversation messages, and episodes searched via BM25 (FTS5) and vector retrieval fused with Reciprocal Rank Fusion, with explainable search.

The benchmark terminal pair-programming agent. Its two signature patterns: a tree-sitter powered repo map that gives the model compressed, ranked codebase context, and diff-based edit formats that make model edits reliable and reviewable.

The project that ignited autonomous-agent interest; now a platform for building and running agent workflows. Historically important for demonstrating both the appeal and the failure modes (loops, drift, cost) of unconstrained autonomy.

Microsoft's multi-agent framework built on conversational agents: agents (and humans) converse to solve tasks, with group chats, tool use, and code execution woven into the conversation model.

A virtual software company of communicating agents organized in a waterfall of chat chains (design, coding, testing, documentation) - a research-grade study of communicative multi-agent software development.

A leading VS Code agent that popularized the human-in-the-loop approval UX: every file edit and terminal command is presented for approval with diff previews, plan/act modes, and checkpoints.

An open-source IDE assistant whose architecture contribution is the context-provider system: pluggable providers (files, docs, terminal, issues) that assemble model context on demand.

A popular multi-agent orchestration framework organized around role-playing crews: agents with roles, goals, and tools collaborating through defined tasks and processes.

Google's Agent Development Kit: a code-first Python toolkit for building, evaluating, and deploying agents with hierarchical multi-agent composition, tool ecosystems, and built-in evaluation.

LangChain's low-level orchestration framework modeling agents as stateful graphs: nodes, edges, checkpoints, and human-in-the-loop interrupts - the infrastructure layer many production agents standardize on.

The multi-agent 'software company' framework: SOPs encoded as agent roles (PM, architect, engineer, QA) that transform one-line requirements into specs, designs, and code.

LangChain's open-source asynchronous coding agent built on LangGraph: plans, executes, and opens PRs for software tasks end to end - an open implementation of the cloud SWE-agent product shape.

A leading open platform for software-development agents that execute long-horizon tasks in sandboxed environments (Docker) with browser and terminal access - the reference for agent-computer interface design and safe execution.

An automated PR review agent providing /review, /describe, /improve commands on pull requests - the reference pattern for wiring agent review into the merge gate.

A terminal agent built for large, multi-file tasks: plans changes across steps, accumulates them in a protected sandbox separate from the working tree, and applies them only when approved.

A fork-descendant of Cline that pushed multi-mode agent UX further: custom modes with per-mode permissions and prompts, letting one agent switch personas (architect, coder, reviewer) with different tool rights.

The Princeton research agent that introduced the Agent-Computer Interface (ACI) concept: carefully designed commands, file viewers, and feedback formats that dramatically improve LLM performance on real GitHub issues (SWE-bench).

Microsoft's model-agnostic SDK for building agents and integrating AI into enterprise apps: plugins as typed functions, planners, and multi-language support (C#, Python, Java).

A large community collection of leaked/shared GPT system prompts and prompt-injection lore. Mined here for prompt-structure patterns: role framing, capability lists, constraint blocks, and output-format contracts.

The earlier Go-based terminal AI coding agent under the opencode-ai org (the lineage that preceded/paralleled sst/opencode). Useful for comparing two takes on the same terminal-agent product shape.

A polished terminal coding agent (from the SST team) demonstrating terminal-native agent UX: streaming TUI, session management, and provider-agnostic model routing.

A multi-agent microservice system built on .NET Aspire, Microsoft Agent Framework, and the A2A + MCP protocols - agents deployed as microservices with proper service discovery and observability.

A modular Python/FastAPI framework combining A2A (agent-to-agent) communication with the MCP pattern - a minimal skeleton for wiring both protocols together.

An MCP server enabling multi-agent orchestration through Claude Desktop: create, manage, and coordinate specialized agents for workflows like financial analysis and research.

A reference architecture connecting Google Cloud Vertex AI reasoning with Oracle Cloud sovereignty requirements through MCP - agentic orchestration across two clouds (data-sovereignty driven).

An MCP server integrating Letta's agent memory capabilities with VS Code Agent Mode - self-improving agents whose memory lives behind MCP tools.

Deterministic guardrails for AI coding agents: policy-as-code that runs the deterministic part of code review (AST checks, regex, diff analysis) against agent plans, diffs, and evidence. Its .rulebound/rules/ and docs/threat-model/ are directly reusable for agent QA.

An experimental MCP agent framework for the Spring/Java ecosystem explicitly based on Anthropic's 'Building Effective Agents' design practices - workflow patterns (chaining, routing, parallelization) implemented over MCP.

A TypeScript port of the mcp-agent framework: type-safe agent construction over MCP with workflow management, logging, and execution control.

An MCP-based communication framework enabling multiple AI agents to collaborate through asynchronous messaging, built with TDD and functional programming principles - a clean, tested reference for MCP server design.

A popular open library for connecting any LLM to any MCP server and building custom agents with tool access - the fastest path from zero to a working MCP-tool-using agent, with support for multi-server clients and restricted tool sets.

The observability and DevTool platform for AI agents: session replays, cost and token tracking, and failure analysis via a lightweight SDK spanning the major agent frameworks.

A Tsinghua platform for large-scale LLM-agent social simulation - thousands of agents with profiles, behaviors, and environments for studying emergent social dynamics.

IBM's Python framework for structured agentic computation: AI pipelines expressed as typed data transformations, grounding agent work in schemas rather than freeform text.

A fully-automated, zero-code framework (HKU) where agents are created and operated through natural language alone - research on making agent construction itself agentic.

An LLM red-teaming framework (from the DeepEval team): 40+ vulnerability probes and 10+ attack methods (prompt injection, jailbreaking, leakage) to adversarially test LLM apps and agents.

Official implementation of Dynamic LLM-Agent Network (paper): agent-team collaboration where the network topology and team composition are optimized dynamically per task.

deepset's production framework for LLM pipelines and agents: composable component pipelines for RAG, tool-calling agents, and retrieval - a mature reference for pipeline-style agent architecture.

The LLM Automatic Computer framework (ICLR 2024): treats the LLM as a CPU with an external memory unit, generating large, consistent codebases far beyond a single context window.

OpenTelemetry-native observability for LLM apps and agents: one-line instrumentation for traces, metrics, cost tracking, plus prompt management and a playground - GenAI observability on open standards.

An agent observability, evaluation, and monitoring platform: trace agent executions, run evals, and manage datasets/experiments across the agent lifecycle.

ServiceNow's framework built around the Tape: a structured, replayable log of the agent session that drives reasoning, debugging, evaluation, and even fine-tuning data extraction across the agent lifecycle.

A multi-agent framework (from Ant Group) centered on domain-expertise patterns: PEER (plan/execute/express/review) and DOE collaboration modes proven in financial-industry deployments.

Example gallery for Langroid, a clean multi-agent programming framework from CMU/UW researchers - practical, minimal examples of agent-to-agent task delegation.