Why Agent Systems Need Explicit Execution Models
Traditional UI-first platforms fail in an AI-first world. SMALL defines execution primitives that make systems legible to machines.
Historical Context: UI-First Systems and Machine Legibility
Many existing platforms optimize for human editors: WYSIWYG interfaces, mutable state, implicit workflows. These abstractions work well for human interaction but are opaque to automated systems. An agent cannot inspect a "content block" or understand a "publishing workflow" without reverse-engineering UI state.
UI-first systems hide contracts behind dashboards. They prioritize ease of use over machine legibility. This works for humans but breaks for automation. Agents need explicit contracts, not inferred state.
SMALL inverts this: schemas define contracts before any artifact exists. Intent declares goals explicitly. Constraints set boundaries. Plans are observable. Progress is evidenced. Handoffs enable resumption. Agents can read, validate, and operate on these primitives without guessing.
Why Agents Require Schemas, Not Dashboards
Dashboards are visual abstractions. They show state but don't expose contracts. An agent looking at a dashboard sees rendered output, not the rules that govern it.
Schemas are contracts. They define structure, validation rules, and constraints. An agent can read a schema and know exactly what is valid, what is required, and what is optional. Schemas are machine-verifiable. Dashboards are not.
SMALL makes schemas first-class. Every artifact conforms to a schema. Validation happens before use. Agents operate on schemas, not on inferred state from dashboards.
Determinism Over "AI Features"
Many systems add "AI features" as afterthoughts: AI-generated summaries, AI-powered search, AI content suggestions. These features are non-deterministic and opaque. They don't integrate with the core system model.
SMALL embeds determinism at the primitive level. Schemas enforce structure. Intent declares goals. Constraints set limits. Progress records evidence. Handoffs enable reproducible resumption. These primitives are deterministic and verifiable.
AI agents operate within this deterministic framework. They generate plans that respect constraints. They produce progress entries with evidence. They generate handoffs for resumption. The system remains legible and auditable even when agents are non-deterministic.
SMALL as Infrastructure, Not Tooling
SMALL is a state protocol. It's not a content editor. It's not a publishing platform. It's not a management system. SMALL is infrastructure: the protocol that makes agent-legible systems possible.
Infrastructure defines primitives. Tooling builds on top. SMALL provides the primitives: Intent, Constraints, Plan, Progress, Handoff. Applications built on SMALL can implement various workflows and use cases, constrained only by the protocol's guarantees.
This distinction matters. Infrastructure is durable. Tooling changes. SMALL defines the state protocol that will outlast any specific tool or product built on it.
The Architectural Shift
The shift to explicit execution models is architectural:
- From UI-first to schema-first
- From implicit goals to explicit intent
- From hidden limits to declared constraints
- From opaque progress to evidenced entries
- From lost context to deterministic handoffs
- From human-optimized to agent-legible
SMALL doesn't eliminate functionality found in existing platforms. It redefines how system state and execution are modeled. Work still gets planned, executed, and tracked. But the primitives are explicit, validated, and automatable.
This is a state protocol: not a product, but a foundational model for agent-legible systems.