Architecture Principles 

Agents only create value when they operate in the real world.

That’s why testing, evaluation, and operational controls are built directly into the platform. If an agent cannot be tested, monitored, and trusted in production, it isn’t ready.

Testing and operations are not afterthoughts — they are part of the architecture.

AI systems exist on a spectrum between agent-centric and workflow-centric architectures. 

Agent-centric systems treat the agent as the primary unit of design. 
Behavior quality, evaluation, observability, and lifecycle management become first-class. 

Workflows still exist, but they are intentionally thin and stable. 
They act as scaffolding around the agent rather than the place where decisions live. 

Guardrails, monitoring, and evaluation surround the agent to continuously measure and improve its behaviour. 

Workflow-centric systems, by contrast, treat orchestration as the primary design surface. 
Flows, branching logic, and execution paths encode decisions because agent behaviour itself is less reliable. 

Both approaches are valid, but they place responsibility in different places: 

• Agent-centric: workflows support agents 

• Workflow-centric: agents are steps inside workflows 

Our platform is designed primarily for agent-centric systems, where reliability comes from agent quality and strong operational controls, not from increasingly complex orchestration logic. 

Complex problems require specialised capabilities.

Rather than forcing a single model to handle everything, we separate:

• Knowledge

• Reasoning

• Tools

• Evaluation

Agents route work to the right capability at the right time.

This reflects a broader architectural direction we call Segregated Attention Architecture (SAA) — a modular model of AI systems where specialized components collaborate rather than competing for attention inside a single monolithic reasoning process.

Agent systems today implement this modularity through orchestration.

Future model architectures will likely embed it directly.

Agent systems should remain understandable.

If you can draw the system on a whiteboard as a group of humans collaborating, the design is probably sound.

If you cannot, the system is likely too complex.

Keeping architectures understandable makes them easier to debug, evolve, and trust.