SimPilot is what I've been building to find out how far agent engineering actually goes when the work is real. You describe a problem in plain English, and a fleet of typed, tool-using agents plans the work, runs it on sandboxed compute, diagnoses its own failures, and hands back a report you can audit. A stress test for the patterns I keep coming back to: long-horizon orchestration, typed protocols, durable memory, and being honest about evaluation.
The agent moves through 23 numbered lifecycle phases. Each has a Zod-typed evidence gate that acts like an eval-style verifier, so it can't move forward without producing the artifact the next phase needs. Because every phase has to produce its evidence, a long-horizon run stays auditable from start to finish.
User intent lives in a mutable spec. The moment it's committed, it freezes into an immutable input package that every downstream tool consumes. Upstream of the freeze, anything can change; downstream, every change is auditable. Prompt-invalidation tracking catches stale assumptions.
Every tool runs inside a Docker image with a strict workspace mount and a command-policy admission gate. Same images locally via Docker Compose, same images in production on AWS Batch / ECS — one debugging surface in both places.
Real tools fail constantly. The Guardian subsystem collects forensic evidence on failure and spawns specialist subagents — a debugger, a UI verifier, a report reviewer — to diagnose and propose a fix. Every recovery is journaled, so retries don't quietly re-introduce the same bug.
A durable memory layer stores domain gotchas, validated precedents, and project patterns. The agent stops relearning the same lesson on every project, which compounds across long-horizon work.
A supervisor / researcher multi-agent loop reads technical literature, vendor docs, and the agent's own memory, then synthesizes a grounded answer that streams back with provenance pointing at real sources.
Most agent demos work because the tasks are short, the tools forgive everything, and a wrong answer is cheap. I wanted to see what happens at the other extreme.
Engineering automation is the cleanest test case I know. The ground truth exists, and an LLM agent can't talk its way around a bad result.
SimPilot is my bet on what a system like that actually needs. The protocol is typed instead of free-form. Memory persists between projects. Tool execution is sandboxed. The multi-agent topology stays narrow enough that each agent does one job. Eval-style verifiers decide whether artifacts are good enough to continue. The domain is engineering simulation, but I care more about the shape of the system underneath.