engineering/

AI agent engineering turns model behavior into a system you can inspect, constrain, and change. It starts with ordinary engineering decisions: define what a tool can do, keep runtime work within clear process limits, and put each rule where the system can enforce it. Those choices come before orchestration. They decide whether a model's actions make sense when a run goes well and whether you can recover when it does not.

Start with the interface and the running process

MCP tool design answers the first question: what does the model need to know when it chooses and calls a tool? Names and schemas are not enough. Descriptions carry defaults, domain language, decision-time instructions, and failure contracts the caller can recover from. An MCP server is defined by that tool contract, not by whether it runs as a separate service.

Claude P backend process takes the next step. It explains what an application must own when it relies on claude -p: process lifecycle, durable run state, duplicate-launch protection, tool discovery and approval, and credential recovery. The command may be short-lived, but the run is not. Skills, subagents and MCP: where logic lives then helps with placement: reusable method belongs in a skill, context-sensitive work in a fresh worker, shared capability behind an interface when the boundary earns its cost, and non-negotiable rules in the service that owns the data.

That gives you the main route through the newer Claude Code and MCP material: contract first, runtime second, placement third. It also marks a limit. Protocol access does not grant domain authorization, and an interface earns its place only when it makes responsibility clearer.

Add safety, evidence, and storage at the owning layer

Deny-by-default grounding shows why confidential material should be filtered before it reaches the model. Authorization and cache isolation belong with the loader. EvalPal's AUDHD assessment makes a related correctness case: validated configuration, import boundaries, encrypted responses, immutable snapshots, and safety seams keep clinical extensions inspectable.

Inspection needs evidence, too. A clean audit run proves nothing separates one stochastic audit sample from structural proof. Shift-left quality in an agentic pipeline explains why defects should be caught at the earliest stage that can expose them, before downstream work makes cold review expensive. Agent run cost attribution assigns each metric to the component that can observe it and deduplicates transcript usage by message ID. That is where an agent hook fits: event-triggered harness code can observe a completed run without posing as a model-facing tool. The result is run accounting that distinguishes exact, partial, and deferred totals.

The ownership rule carries into data design. AI memoir from interviews keeps a finished interview transcript immutable and traces later prose back to source fragments. One process, one file shows when a single-user system can keep its UI, MCP routes, and SQLite together until writer or lifecycle limits change. Vectors in the file adds semantic search as a derived index while preserving keyword search and explicit fallbacks. Growoperative's FOAF protocol architecture maps a different boundary: trustline routing and atomic settlement can sit behind an ordinary dollar-denominated tab, but planned and live parts must stay distinct.

Where to start, and where this hub ends

Start with MCP tool design, continue to the claude -p backend process, then use the logic-placement essay to decide whether a capability belongs in instructions, a worker, an interface, or the data-owning service. Read the safety and evidence essays before the storage examples. Move to frameworks when the question becomes how several roles or stages should coordinate, and to memory when the question is what the agent should retain or retrieve.