SimPilot is my answer to a question I couldn't stop poking at: how far does agent engineering actually go when the work is real — when a wrong answer costs money and the ground truth doesn't negotiate? It's a stress test for the patterns I keep coming back to: long-horizon orchestration, typed protocols over free-form prompts, durable memory, and being honest about evaluation. The domain is engineering simulation; the interesting part is the system underneath.
The agent moves through six typed phases — plan, specify, execute, diagnose, validate, report — each handled by a role-bounded agent. Every phase carries a Zod-typed evidence gate that acts like an eval-style verifier, so it can't advance without producing the artifact the next phase needs. 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, content-hashed input package that every downstream tool consumes. Upstream of the freeze, anything can change; downstream, every change is a new auditable version — and the same bytes always replay to the same result.
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.
Destructive or open-world tool calls pass through an admission reviewer that defaults to deny when the context is thin. When a run breaks, a dedicated diagnose phase inspects the failure and proposes a recovery — and every recovery is journaled, so a retry can't quietly re-introduce the same bug.
A durable, tiered memory layer (user, project, org) 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 research step reads technical literature, vendor docs, and the agent's own memory, then synthesizes a grounded answer that streams back with provenance pointing at the real sources it used.
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 simulation doesn't forgive. 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.