Pillar I
Agentic infrastructure, made operational
The how behind intelligent systems. Not prompting tricks or model comparisons, but the practical layer that makes agents reliable enough to trust with real work: protocols, tool design, context engineering, memory systems, and the orchestration patterns that hold them together.
This pillar carries the method. The other two pillars give the work its direction and its edge. This one explains how the systems are actually built.
Implementation layers
The stack beneath useful agents, from protocol to orchestration.
Protocols
Tool calling & MCP
Tool calling is the loop that makes agents useful: provide tool definitions → model emits tool calls → application executes → tool output returns → model continues reasoning. MCP (Model Context Protocol) extends this to remote servers via JSON-RPC 2.0, giving models access to tools, resources, and prompts from any conforming server. The protocol isn't the interesting part — what you build on top of it is.
Ergonomics
Tool design as UI for agents
Tools are the agent's interface to the world. Bad tool design degrades reasoning: vague descriptions cause misuse, noisy outputs waste context, overlapping tools create ambiguity. Good tools have a single clear purpose, a precise name that implies what it does, and return only the signal the model needs for its next step. This is interface design — it just happens to be for agents, not users.
Context
Context engineering
What enters the context window at each agent step determines reasoning quality. Context engineering is the practice of shaping those inputs deliberately: write durable facts to external memory, select only relevant history via retrieval, compress verbose outputs before they enter context, and isolate tool outputs that shouldn't contaminate the main reasoning trace. Most agent failures are context failures.
Memory
Agent memory systems
Memory is what separates a stateless chatbot from an agent that accumulates understanding. The layers: in-context (fast, ephemeral), external storage (persistent, retrievable), and semantic memory (structured, queryable). The hard problem isn't storage — it's deciding what's worth remembering, how to retrieve it when relevant, and how to let old memories expire without losing what matters.
Orchestration
Control-flow patterns
Agents compose into systems through a small set of patterns: routing (classify → dispatch), parallelisation (fan out → aggregate), orchestrator-worker (plan → delegate → coordinate), evaluator-optimiser (generate → evaluate → iterate), and the foundational ReAct loop (reason → act → observe). These patterns aren't magic — they're the grammar of reliable agent behavior.
Projects in this pillar
Concrete systems where the infrastructure work becomes legible.
symbolic-ontology-mcp
MCP server for symbolic reasoning. Structured knowledge representation for AI agents — where agentic infrastructure meets the boundary.
symbols-awakening-mcp
MCP server for symbolic and archetypal knowledge. Bridges structured meaning-making with agent-accessible APIs.
Go deeper
AI Tooling →
MCP, tool design, context engineering, memory, evals, and guardrails.
Go deeper
Agentic Workflows →
Control-flow patterns, state, human approval, and operational safety.
From the build log
Field guides, pattern analyses, and writing from inside the systems work rather than around it.