A trait model for effective AI
Most conversations about AI capability start and end with the fourth layer: how smart is the model, how fast does it run, how large is its context window. Those numbers are easy to benchmark and easy to market, which is exactly why they dominate the discourse. But raw capability is only one layer of what makes a system effective in the way we define it — solving the problem at hand while remaining sustainable, durable, and viable over the long term.
We use a four-layer framework to reason about this more completely.
Layer 1, Governance, covers trust and alignment: sovereignty (self-governance and data ownership, independent of any single vendor), pluralism (the ability to serve different cultures, languages, and values natively), and auditability (letting independent parties verify how a decision was reached). Without this layer, everything built on top of it inherits someone else’s incentives.
Layer 2, Architecture, covers structure and integration: decentralization removes single points of failure, composability lets components be swapped or stacked, interoperability lets a system exchange data across platforms, and portability lets a model and its data move between providers without degrading. Together these determine whether a system can actually be owned, rather than merely rented.
Layer 3, Behavior, covers live execution and cognition: controllability (can a human steer or stop it), adaptability (can it adjust without retraining), state awareness (does it remember), robustness (does it hold up under adversarial pressure), explainability (can its reasoning be audited), and determinism (do identical inputs produce identical outputs). Most frontier labs optimize hardest for capability and softest for this layer — and it shows.
Layer 4, Capability, is the computational engine: intelligence density, throughput and latency, context window, multimodality, and agency ceiling. This is the layer everyone measures. It matters, but it’s the top of the stack, not the foundation.
The traits don’t sit in isolation. Some pairs are constitutive — intelligence density is necessary for both agency ceiling and explainability, decentralization is necessary for sovereignty. Others are in tension — throughput scales context window but impairs determinism, and maximizing agency ceiling constrains controllability. Effective system design isn’t about maximizing every trait; it’s about resolving these tensions deliberately.
Two examples of that resolution in practice. Controllability versus agency ceiling can be resolved with asynchronous guardrails: let the system plan and act freely inside a sandbox with a hard budget, and fall back to a human the moment a safety parameter is challenged. Throughput versus determinism can be resolved with tiered precision channels: lock compliance and security logic to sequential, zero-temperature processing, and let creative or exploratory tasks run on faster, more variable paths.
This is the model we use to evaluate our own stack, and the one we’ll keep refining as we publish more here.