1. Architecture Over Abstraction
Premature adoption of high-level agent frameworks hides system boundaries, state transitions, and network overhead behind leaky abstractions. Production engineering requires explicit control over every RPC, token boundary, and serialization step.
Before choosing a model or orchestrator, map the exact system topology: data ingress paths, state stores, authorization boundaries, and failure cascades. A system that cannot be drawn as an unambiguous state machine cannot be trusted in production.
2. Explicit State Transitions
Autonomous systems must never operate with implicit, ambient state. Every agent state mutation must be recorded in an immutable, append-only transaction log.
If an agent crashes mid-turn, the system must either resume deterministically from a signed checkpoint or execute an atomic rollback to a known invariant. Unconstrained loops without strict step budgets are design bugs.
3. Context is an Engineering Resource
Treating context windows as infinite trash bins degrades reasoning accuracy (the "lost in the middle" effect), explodes quadratic attention latency, and escalates GPU memory consumption.
Context must be actively constructed, pruned, and filtered using temporal recency, semantic relevance, and domain priority. Less relevant tokens in prompt space directly increase the probability of hallucinated reasoning paths.
4. Model Independence & Specialization
No enterprise architecture should depend irreversibly on a single model checkpoint or proprietary API provider. Model APIs change weights, deprecate versions, and throttle concurrency without notice.
Engineer decoupled inference interfaces. Route high-level planning to frontier reasoning models, and delegate fast deterministic sub-tasks (JSON extraction, classification, embedding) to fine-tuned, sovereign open-weight models running on private GPU nodes.
5. Zero Ambient Authority
Model output is an untrusted proposal. A language model predicting a function call syntax does not constitute permission to execute that function.
Every proposed action must be validated against a deterministic policy gate with scoped permissions, cryptographic identity tokens (mTLS/SPIFFE), and payload schema validation. Tools must execute inside isolated, resource-metered micro-sandboxes.
6. Physical Infrastructure Constraints
AI systems are hardware systems. Memory bandwidth, PCIe transit times, thermal envelopes, and KV-cache fragmentation are physical realities that dictate latency SLAs.
A 70-billion-parameter model at 16-bit precision requires 140 GB just for static weights before allocating a single byte to KV cache. Optimizations like continuous batching, PagedAttention, and FP8 quantization are not premature optimizations; they are the difference between viable unit economics and unsustainable compute spend.
7. Quantitative Evaluation Over Subjective Inspection
"It looks good in my browser" is not an engineering metric. Systems must be continuously evaluated against automated test suites containing hundreds of hard edge cases, boundary perturbations, and adversarial injection attempts.
Track quantitative signals: Task Success Rate, Time-To-First-Token (TTFT), Inter-Token Latency (ITL), Tool Call Precision, Retrieval Recall@K, and P99 End-to-End Turnaround.
8. Graceful Degradation & Clinician/Human Oversight
Systems will encounter unknown environments, corrupt data, and unresolvable edge cases. When an invariant fails, an agent must never silently guess or forge a response.
Implement fail-closed circuit breakers. The system must cleanly halt, summarize the exact boundary violation, and escalate control to qualified human operators or attending clinicians. In high-stakes domains, the human remains the final authority.