Agency Engine

The core of your next product.

Agency Engine is the shared application core for product teams building AI apps, so that each new app starts with approvals, records and permissions already in place.

  • Foundation
  • Product builders
  • Governed applications
  • Policy & audit trail
Product composition and durable work. An illustrative process for composing product services and retaining organization work.
Loading model
Technical descriptionsInteractive model unavailable. The static illustration and descriptions remain available.
Versioned foundation
Preserve shared contracts and the declared protected control set.
Technical data

Inputs

Versioned kernel and compatibility contracts.

Transformation

Preserve shared contracts and the declared protected control set.

Retained state and outputs

Versioned kernel and compatibility contracts.

Policy, evidence, approvals, model access, disclosure and custody.

Constraints

Product configuration cannot remove the protected control responsibilities.

Product composition resolver
Validate the declaration and select domain services and interface vocabulary.
Technical data

Inputs

Versioned service and interface selection.

Protected and replaceable seams.

Selected reviewed version; earlier work retains earlier lineage.

Transformation

Validate the declaration and select domain services and interface vocabulary.

Retained state and outputs

Configured, refused and unknown states.

Selected product services, shell and versions.

Constraints

An invalid or unsupported declaration remains refused or unknown.

Organization context
Supply organization records and restrictions independently from reusable product identity.
Technical data

Inputs

Selected organization records and roles.

Inherited limits that local context cannot widen.

Transformation

Supply organization records and restrictions independently from reusable product identity.

Retained state and outputs

Roles, relationships and current operational records.

Installation, organization and workspace may narrow inherited authority.

Constraints

Local configuration may narrow inherited authority; it does not create a broader grant.

Plan and process compiler
Translate proposed work into typed steps, dependencies, budgets and available routes.
Technical data

Inputs

Current work context and effective restrictions.

Typed intended work and output.

Completed prefix and unresolved work for the next plan.

Transformation

Translate proposed work into typed steps, dependencies, budgets and available routes.

Retained state and outputs

Declared work/output contracts.

Cycles, missing routes and budget/policy diagnostics.

Constraints

Missing routes, cycles and budget or policy conflicts remain visible diagnostics.

Contracted service workbench
Perform the selected domain method through its eligible execution ports.
Technical data

Inputs

Valid product composition.

Eligible typed steps and declared execution ports.

Transformation

Perform the selected domain method through its eligible execution ports.

Retained state and outputs

The selected commercial or organizational method.

Draft/result, explicit wait or unavailable integration.

Constraints

An unavailable integration remains unavailable; a draft is not an external delivery.

Durable work and versions
Reconstruct work from transitions and keep replaced methods/agents identifiable.
Technical data

Inputs

Actual result, wait or indeterminate transition under its work identity.

Reviewed method/agent replacement with a new version.

Transformation

Reconstruct work from transitions and keep replaced methods/agents identifiable.

Retained state and outputs

Completed results, pending obligations and anomalies.

Earlier versions remain; restoration creates a new version.

Constraints

A replacement or restoration retains earlier versions and pending obligations.

An illustrative process for composing product services and retaining organization work.

Additional mechanisms are described in the technical reference.

A versioned foundation supports product composition and organization context. Together they shape a bounded plan, contracted service work and a durable record of the result.

One foundation. Products with a life of their own.

Discuss a product foundation

A common core can become a very different experience.

A new AI application needs its own workflows, language and interface. Rebuilding the shared controls for every product can leave each application with a different approach to permissions, evidence and recovery.

Use Agency Engine when you need a distinct product or an organization-specific installation on a shared application foundation. Begin with the product’s work objects and operating responsibilities, then compose its services around the protected controls.

SuperSell, built on the engine, organizes commercial conversations; a vertical installation for a law firm or a logistics operator would look nothing like it. Their users encounter distinct products on one governed core.

The kernel

Shared contracts and controls establish the common operating basis.

The runtime

Durable work objects, process transitions and execution ports carry the selected product into operation. Replaying recorded transitions reconstructs state without a new reasoning call.

The product

Selected services, interface composition and domain methods give an application its own behavior and vocabulary.

The organization

People, client relationships, mandates and operational records belong to the organization using the product.

Make the extension seam explicit.

A resolved product declaration travels from tooling through the backend to the frontend.

The application consumes that composition at runtime. Invalid configuration has a refused state rather than silently exposing the whole engine. Replaceable services use contracts around a protected set of policy, evidence, approvals, model access, disclosure and custody controls.

The decision model can apply default denial, overriding prohibitions, principal-bound approval and recipient constraints. Coverage is defined for specific startup and execution paths; an application still needs its own threat model.

Can a new app launch without rebuilding governance?

The product lead decides each release; the shared core supplies approvals, records and permissions. Illustrative.

  1. 1 of 4A product lead starts a dispatch app for a regional logistics firm on the shared core, with approvals, records and permissions in place.
  2. 2 of 4The app gets its own name, screens and workflows, built on top of the same core.
  3. 3 of 4The firm’s people, customers and records stay in the firm’s own layer, apart from the product.
  4. 4 of 4Each agent the app runs has a version an auditor can open, and the product lead decides when it ships.Decision: The product lead decides the release.
Select any part of the drawingScroll to step · Esc to skipFig. 1
  1. 1 of 4An engineer swaps the app’s routing service through its contract, around the protected approval and evidence controls.
  2. 2 of 4A configuration that would expose the whole engine is refused at startup, and the refusal is recorded.
  3. 3 of 4The firm’s own policy can tighten what the app may do; it cannot widen the core’s authority.
  4. 4 of 4The product lead approves the change, and the record ties it to the version that runs.Decision: The product lead approves the new service.
Select any part of the drawingScroll to step · Esc to skipFig. 1
  1. 1 of 4A product lead creates a dispatch agent from a strict template with its own test cases.
  2. 2 of 4Independent cases and injection canaries test the agent before anyone deploys it.
  3. 3 of 4Version 2 replaces version 1; version 1 stays in the history, and restoring it creates version 3.
  4. 4 of 4Deploying to the firm’s workspace is its own release decision, made by the product lead.Decision: The product lead releases version 2.
Select any part of the drawingScroll to step · Esc to skipFig. 1

What the research says

Apps multiply faster than their governance.

81%1
of SaaS spend is controlled by business units; IT directly manages 15%
20.0%2
of EU enterprises with 10 or more employees used AI in 2025, up from 13.5% in 2024

Business units control 81% of SaaS spend, and the share of EU enterprises using AI rose from 13.5% to 20% in one year. New AI apps will keep arriving from the business side, each needing approvals, records and permissions. Agency Engine supplies those once, so a product lead spends the launch on the product itself.12

Inside the mechanism. Change the product, retain the protected seam.

Illustrative scenario. A shared foundation supports a sales application and an organizational workbench with different user experiences.

Product vocabulary follows commercial work.

The selected services connect business knowledge, offers and invited conversations.

Kernel
Shared contracts and protected governance set.
Runtime
Durable work transitions and execution ports.
Product
Commercial methods and the SuperSell experience.
Organisation
The seller’s people, relationships and current records.

A different product selects a different working method.

The workbench specializes briefs, procedures, review and delivery without turning every organization into an engine fork.

Product change
Replace the domain service through its contract.
Preserve
The sealed policy, effect and evidence boundary.
Organization change
Apply the client’s roles and procedures in its own layer.
Version history
Retain replaced agent versions; restoration creates a new version.

Where it changes the work.

Illustrative situations, connected to the mechanisms that make them possible.

Launch another product from the same core

Product organizations

A new application needs its own workflow, language and interface.

How it works
Compose a product-owned shell and selected services above the sealed governance core.
What changes
The team can change the experience without rebuilding approvals, evidence and custody controls.

Make an organizational installation

Enterprises

A common application must reflect local permissions and operating context.

How it works
Installation and organization layers supply context while policy can only narrow inherited authority.
What changes
Local specialization retains a comprehensible relationship to the foundation’s controls.

Let a useful method return to the platform

Software teams

A product discovers a mechanism that another product could use.

How it works
Promote the reusable part through the core’s versioned interfaces while preserving its provenance.
What changes
Shared engineering can improve without copying a product’s private business context.

A useful product carries work through a process.

The selected orchestration design connects adaptive planning to a typed plan, durable execution and a workspace where people can inspect progress.

  1. Compile the plan

    Translate proposed work into typed steps and declared execution ports.

  2. Retain the transition

    A durable process record supports replay of recorded transitions and recovery.

  3. Improve the memory

    Promotion, retention and forgetting have explicit rules. Recurrence can suggest a useful lesson; evaluation determines whether that lesson improves future work.

An agent has a version you can examine.

The studio makes a created agent an inspectable product object, with a template, bounded settings and a recorded history.

Start from a contract

Strict templates and independent cases define the behavior expected from the configured agent. Injection canaries examine selected failure conditions.

Keep the earlier version

Replacing an agent retains the previous version. Restoring an earlier configuration creates a new version, preserving the intervening record.

Separate draft from deployment

Creating and testing an agent does not itself deploy it remotely. The target environment and its authority require their own release decision.

Questions about Agency Engine.

Must every product include every engine service?

Product composition selects the services and interface that serve its domain. Shared governance and compatibility contracts define how that specialization can operate.

Can different organizations use the same product?

The architecture separates reusable product identity from each organization’s people and records. Deployment, data isolation and available workflows are scoped for the intended release.

Agency Engine in the stack.

Product expression

Commercial assistance

A distinct product built from the engine.

Delivery system

Build the product

Architecture, integration and delivery around a selected application.

Technical reference6 mechanisms · 1 further section

The mechanisms underneath.

The technical choices that give Agency Engine its particular behavior.

Runtime product composition
A resolved declaration connects tooling, backend and frontend. Invalid configuration has a refused state.
A protected control set
Policy, evidence, approvals, model access, disclosure and custody form a protected set around replaceable service contracts. Coverage is stated for the implementation paths.
A shared policy decision model
Default denial, overriding prohibitions, principal-bound approval, recipient constraints and autonomy ceilings give routes a common decision vocabulary.
Organization as a separate layer
Reusable product identity and methods are distinct from a specific organization’s people, client relationships and operational records.
Durable process design
The selected orchestration design connects adaptive planning to typed plans, durable execution and an observable workspace.
Explicit memory changes
Promotion, generalization, retention and typed forgetting follow declared rules whose usefulness can be evaluated separately.

A common core can become a very different experience.

Agency Engine separates a shared kernel, service and interface composition, product identity and organization context. Distinct applications can specialize their experience around common controls and versioned contracts.

The kernel. Shared contracts and controls establish the common operating basis.

The product. Selected services, interface composition and domain methods give an application its own behavior and vocabulary.

The organization. People, client relationships, mandates and operational records belong to the organization using the product.

System story

From a hard problem to an accountable system

An illustrative custom-development journey from a recurring operational problem to handover.

Follow the story

Which app would your product lead launch next if approvals, records and permissions were already done?

Discuss a product foundation