What Closure is

Closure Platform is an enterprise runtime for semantic applications — products whose UI, workflows, AI, integrations, and governance all live in one product graph.

You buy a platform to build and run real applications (portals, intake, catalogs, ops consoles) that your IDE can change under policy — while Form.io, ServiceNow, CRM, and peers stay the systems of record.

Applications as graphs. Intelligence on the same substrate.

That line is the category. Everything below is how it works — and why it matters now.

Architects: also read [The Product Graph](/docs/product-graph) — why semantic data changes software forever.

Executive Summary

Enterprise software has always separated the application from its intelligence.

The application lived in code. AI lived beside it — copilots, agents, and chat that could talk about the product but could not safely be the product.

Closure ends that split.

The application and its intelligence share one governed product graph. Experiences render from it. Workflows execute from it. Knowledge grounds AI on it. Integrations seal into systems you already trust. Events become organizational memory — and that memory now closes two loops: Issues that the platform can heal, and Goals that become governed Change requests the platform can execute.

People and AI change the product itself as data, under the same governance.

That is why products can evolve continuously instead of being rewritten.

Closure keeps systems of record authoritative. We make them more valuable: branded Experiences, hybrid human–agent journeys, IDE-speed authorship, and pre-write governance that improves every sealed record.

1. What you can build

Concrete outcomes first. Closure is for shipping work like this:

If you are evaluating Closure, start here: pick an outcome you already need, not a vocabulary tour.

2. Why now

This architecture was impractical five years ago.

Before large language models, software had to be hardcoded. Changing a product meant changing codebases, tickets, and release trains. “Intelligence” was rules engines and reports — not something that could safely reshape the application.

LLMs changed the economics of change. Models can reason over structured objects, propose edits, and operate tools. What they lacked was a product model they could mutate under governance — not just APIs to call from chat.

Closure is that model: the application as a typed graph, with policy, vault, audit, and Events as first-class citizens. Coding agents still help where code belongs (Platform services, connectors, host shells). The center of gravity moves to product data — so IDE agents become useful at product speed without becoming uncontrolled rewrite engines.

Why now: models can finally operate on products as data. Enterprises need that capability with systems of record, not against them.

3. What Closure is not (orientation)

Buyers often ask whether Closure is “another low-code,” “another AI platform,” or “another workflow engine.” Here is the orientation:

Low-code accelerates screens. Workflow tools automate steps. AI platforms add chat. Closure unifies the product and its intelligence so change, audit, and evolution share one structure.

4. The thesis: semantic applications

A semantic application is a product whose behavior is stored as governed data: Experiences, Workflows, Knowledge, and Integrations on one org graph — with an Ops plane (Runs, Events, Issues, Goals, Versions) recording and steering how that product lives.

Forms, conversation, and autonomous agents are views of the same process — change the journey once; every interface stays aligned.

              Product graph (UI · process · knowledge · integrations)
                                   │
        ┌──────────┬───────────────┼───────────────┬──────────┐
        ▼          ▼               ▼               ▼          ▼
    Renderer   Query API      Workflows       Knowledge     Ops
   (Experience)              (runtime)      (RAG + tools)  (memory)
        │          │               │               │          │
        └──────────┴──── binds · actions · search · audit ────┘
                                   ▲
                                   │
                     Your IDE (Platform MCP)  ·  Console

Deploy is promoting the product graph — an Org Release pinned from Dev → Test → Prod — not inventing a second architecture for “shipping the app.”

5. A new paradigm for engineering

5.1 From code that represents a product → a product that exists as data

Engineers still write code where it belongs. What changes is the center of gravity: customer product behavior lives as governed data. That is what makes IDE agents safe at product speed.

5.2 Your IDE gets a product model

Most AI companies say: we have an assistant.

Closure says: keep Cursor, Claude Code, and VS Code — and give them a product model.

• Your IDE via MCP — npx @closurenetwork/ide installs the rails; the model reasons locally; Closure SaaS (or private tenancy) owns the graph, forms, vault, and audit. Authorship runs through platform_* tools: scaffold, targeted craft, governed builds, runs, releases.
• IDE agents as process citizens — a workflow can pause at an agent node in waiting_ide; your IDE picks up the task, does the work, and submits it back into the governed run.
• The Closure console — review, approvals, and visual editing for teams who start from the browser rather than the editor.

Closure does not replace your IDE. It gives your IDE a product model.

Secrets open as form workflows, vaulted per organization, connector, and environment — authorship stays precise without credentials in chat.

5.3 Experiences are real products

An Experience is a hostable application: navigation, pages, components, themes, and actions — rendered from the graph, previewable in Dev / Test / Prod, promotable as product state. Custom domains attach per environment — dev., test., and production hostnames resolve to the same graph with automatic TLS. Agencies and vertical teams ship branded products on Closure while process and seals remain on the same Workflow Graph.

Experience Packs make this commercial: an installable atom that carries Experiences, workflows, knowledge, and a connector checklist into a new organization — objects and process, never secrets.

6. A new paradigm for process

6.1 One engine, two disciplines

Closure runs one workflow engine with two authoring facets:

• Process — BPM discipline: forms, gateways (parallel / inclusive / event-based), waits and timers, foreach, compensation, subprocesses, human gates.
• Agentic — AI discipline: agent nodes with goals, tools, skills, and multi-agent orchestration patterns (single, pipeline, supervisor, swarm) inside a single governed node.

These are facets of the same graph, not two products. A claims process can run deterministic steps, fan out to an agent team for triage, return through a human gate, and seal the result — one run, one audit trail.

6.2 Pluggable agent brains

Every agent node declares an executor:

The graph is the contract; the brain is pluggable. Governance, Events, and audit are identical regardless of who executes.

6.3 Governed loops

Decision nodes can carry a loop: do the work, verify with deterministic tools, repair and retry under an explicit budget. Verification is part of the process definition — not a hope expressed in a prompt.

7. A new paradigm for intelligence

7.1 Intelligence inside the product

Agents in Closure are process citizens: they run under policy, escalate to humans when judgment requires it, retrieve from Knowledge, and leave durable evidence. They do not sit beside the application as a parallel product. They operate as the application’s intelligence — because the application is already data.

7.2 Knowledge matched to how models work

Context is governed and auditable. Retrieval is part of the product. Tools synced from MCP connectors and custom handler:code functions live on the same shelf as documents — because for an agent, what it can do is knowledge too.

SyncProfiles keep that knowledge current: declared source resources, field mappings, and an ingest workflow that lands external truth (HubSpot, Stripe, SharePoint, webhooks) as governed objects — ELT-lean, not a warehouse project.

7.3 Organizational memory that closes two loops

Events record what happened across Experiences, Workflows, Knowledge, and Integrations. They power operator Activity and compliance trails. But memory alone is not improvement. Closure separates the two loops that act on it:

The healing loop — Issues.

1. Scan workflows (ops, brand, i18n, discoverability, contracts, security — the drift suite) read the graph and open Issues. Only workflows open Issues; raw telemetry never does.
2. Heal workflows fix what policy allows — tiered from deterministic tools up through LLM-assisted repair — and escalate what they must not touch (leaked secrets, PII).
3. On higher plans the loop runs autonomously: scan, heal, re-scan — and a quality gate can block promotion while high-severity Issues stay open.

The evolution loop — Goals → Change requests.

1. A Goal captures stakeholder intent — an attractor, not a task.
2. Approving a Goal drafts a Change request: an executable work order with a plan, written by the platform, reviewed by a human.
3. Approving the Change request starts a governed build that changes the product graph — under the same versioning and audit as any human edit.

Two gates, by design: approving intent is not approving work. Intelligence that can only chat is a feature. Intelligence that can heal the product and propose its next version — under governance — is a platform.

8. Environments, releases, and collaboration

• Dev | Test | Prod are organization-level environments. Connector secrets are sealed per environment; mutations are blocked on Test and Prod.
• An Org Release pins the product — Experiences, Workflows, Knowledge, and integration configuration as one immutable version. Promotion moves the pin. Ops streams (Runs, Events, Issues, Goals) are per-environment and never promote.
• Local workspaces give each builder a personal draft overlay — fork, edit, merge to Dev with conflict detection — without pretending git branches are the product.
• Promotion gates scale with trust: open, admin-approval, or dual-control — and the quality gate can hold the pin while the drift suite reports open problems.
• Enterprise deploys run the same platform image on your cluster via a Helm/Terraform kit; the SaaS and self-hosted control planes share one architecture.

9. Partnership — systems of record stay authoritative

Closure’s posture: complement, seal, amplify.

Keep Form.io, ServiceNow, CRM, and collaboration platforms as systems of record. Closure is the adaptive product layer — Experiences, hybrid journeys, Knowledge, and Events — that makes those platforms more valuable.

Form platforms (e.g. Form.io)

Import form definitions into Closure collect journeys. Run wizard, chat, or agent modes with human gates where risk demands it. Seal submissions back when Form.io remains the storage and design SoR.

ITSM & operations (e.g. ServiceNow)

Import catalog shapes into Workflow Graphs. Run branded Experiences that feel like the buyer’s product. Hybrid paths collect, decide, and escalate; then seal Cases, Tasks, and related records into ServiceNow.

In-platform AI (such as ServiceNow Otto) governs work on Now. Closure governs Experiences and multi-system journeys that complete into Now — complementary planes, shared success: higher-quality structured work where operators already live.

Dual-system journeys

Branded Experience (Closure)
        │
   collect → agent + Knowledge → human gate (when material)
        │
   ┌────┴────┐
   ▼         ▼
Form.io   ServiceNow

Forms platforms perfect structured collect. ITSM platforms perfect operational truth. Closure composes them into a product Experience — without asking anyone to abandon their SoR.

Partners win with more volume, better data quality, and faster time-to-value on their platforms. Customers win with one adaptive layer across tools they already trust.

10. Trust is part of the architecture

Agentic enterprise software succeeds when structure and accountability ship with the product.

• Org-scoped identity and sessions — Principals (human, agent, service) distinct from the customers your product serves
• Policy on agent tools and seals; capability-scoped IDE keys
• Vaulted connector secrets, sealed per organization, connector, and environment
• Retrieval audit for Knowledge; static scan on sandboxed code tools
• Durable Events and run evidence, including agent pause/resume and tool calls
• Versioned change — draft → approve → active; releases pinned, promotion gated
• The drift suite as continuous conformance: brand, i18n, discoverability, contracts, security — scanning the product because the product is data

AI makes processes — and the applications that carry them — intelligent inside guardrails.

11. Who this is for

12. Closing

The first generation of enterprise software was pages. The second was workflows. The third is being sold as agents.

Closure proposes a fourth: semantic applications — products that exist as governed data, with code as the runtime around them; IDE agents that author by changing that product; deploy as promotion of the product itself; Events as organizational memory; Issues and Goals as the loops that heal and evolve it; systems of record as the durable home of truth.

The next generation of enterprise software will be defined by whether the application can be understood, changed, audited, and improved as data — and whether intelligence can operate inside that same structure with partners, not against them.

What you buy: Closure Platform — the enterprise runtime for semantic applications.

What you believe: the product should exist as governed data; intelligence should live on the same graph; systems of record should stay authoritative.

For the mechanism behind the vision, see The Product Graph.

Applications as graphs. Intelligence on the same substrate. Governance all the way down.