Agentic Apps · 04.01
Introducing Agentic Apps: A New Category of Software
Not a chatbot, not a script, not a SaaS app with an AI feature bolted on. An Agentic App is durable software built from four real pillars — data, interface, orchestration, and its own Brain.
Two shapes the industry already has. This is the third one.
Right now, "AI software" comes in two shapes, and both have a hole in them. The first is the chatbot: a conversation window bolted onto a model, with no durable product surface of its own, no real data model, and memory that resets the moment you close the tab or switch providers. The second is ordinary SaaS with an AI feature: a static product a human designed once, that an agent can maybe call into, but that has no agency of its own — it doesn't staff itself, doesn't notice when it's broken, doesn't repair itself.
An Agentic App is a third thing, and it doesn't have an established name in the industry yet because nobody else has shipped the whole stack at once: it is real, durable software — a typed datastore, a live interface, a running product — that is built, staffed, operated, and repaired by agents, continuously, for as long as it exists.
The four pillars — not a feature list, the actual architecture
An Agentic App is not a metaphor sitting on top of a workflow. It is four real, load-bearing pillars, and skipping any one of them would make the term dishonest:
| Pillar | What it actually is |
|---|---|
| Data | A real typed datastore — collections, records, optional strict schemas — with a live data loop: what a run does and what the product shows are never two things that can silently drift apart. See The Datastore & the Data Loop. |
| Interface | An agent-authored, typed ViewNode surface — not raw HTML an agent free-hands, but a generated, schema-validated view tree classified into a design archetype and passed through a deterministic repair pass before it's ever shown. See Surfaces Are Typed, Not HTML and The Taste Engine. |
| Orchestration | Not one workflow — usually several, chained into a real pipeline via dependsOn, scheduled, and capped for concurrency by the App Orchestrator. See App Orchestration: Chaining Workflows. |
| Brain | Arguably the most important and the easiest to miss: the App's owner agent accumulates real, graded lessons from every outcome, and recurring lessons graduate into skills that agent inherits going forward. This is not a metaphor — it deposits into the same formation pipeline the rest of the Brain uses. See The App's Own Brain. |
Underneath all four, staffing and live operability make the whole thing a product rather than four disconnected mechanisms: a standalone workflow auto-wraps into an App-of-one the instant it's built, App Staffing assembles a real cast at birth, and live ops plus presence mean a human can watch it work and step in — a product you stand next to, not a cron job you hope succeeded.
Proof, not a slogan
Every claim above is a real, inspectable mechanism, not marketing: the staffing algorithm is idempotent and non-throwing (see App Staffing); a surface that renders a dead data binding gets caught and removed by a deterministic audit, not shipped as a convincing-looking lie (see Bounded Styling & Operability); every workflow inside an Agentic App settles through the Workflow Engine, where completion and accomplishment are different, checked facts. The rest of this category is that proof, read start to finish.
Continue
The scoring mechanics behind recall: freshness decay, trust weighting, reranking, and MMR diversification, explained with real inputs.
One end-to-end walk through what actually exists in the database and who touches it — from build_workflow to a staffed, data-backed, self-orchestrating product.