SMALL Is the New CMS
Traditional CMS abstractions fail in an AI-first world. SMALL replaces them with agent-legible primitives.
Why CMS Abstractions Fail for AI
CMS platforms optimize for human editors: WYSIWYG interfaces, mutable state, implicit workflows. These abstractions are opaque to agents. An agent cannot inspect a "content block" or understand a "publishing workflow" without reverse-engineering UI state.
CMS 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 UI exists. Manifests declare intent. Artifacts are versioned and immutable. Lineage is explicit. Lifecycle events are observable. 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 materialization. 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. Manifests declare intent. Lineage records provenance. Lifecycle tracks state transitions. These primitives are deterministic and verifiable.
AI agents operate within this deterministic framework. They generate artifacts that conform to schemas. They produce lineage records. They emit lifecycle events. The system remains legible and auditable even when agents are non-deterministic.
SMALL as Infrastructure, Not Tooling
SMALL is not a CMS replacement. It's not a content editor. It's not a publishing platform. SMALL is infrastructure: the execution model that makes agent-legible systems possible.
Infrastructure defines primitives. Tooling builds on top. SMALL provides the primitives: Schema, Manifest, Artifact, Lineage, Lifecycle. Applications built on SMALL can be CMS-like, but they're not required to be.
This distinction matters. Infrastructure is durable. Tooling changes. SMALL defines the minimal execution model that will outlast any specific tool or product built on it.
The Shift
The shift from CMS to SMALL is architectural:
- From UI-first to schema-first
- From mutable state to immutable artifacts
- From implicit workflows to explicit manifests
- From hidden state to observable lineage
- From human-optimized to agent-legible
SMALL doesn't eliminate CMS functionality. It redefines how that functionality is modeled and operated. Content still gets created, validated, and published. But the primitives are explicit, versioned, and automatable.
This is the new CMS: not a product, but an execution model.