The deep architecture, for the CTO and the chief architect. See it run in three weeks →
The Auto Platform

How Self-Driven Software actually works.

Under the hood, an Auto is more than a chatbot with a few tools attached. It is a small self-driving operation.

Digital workers reason over a living map of the business, stay inside firm rules, run on a system built so it never loses its place, and record every step. This page opens the hood, in plain terms first, with the technical terms beside them.

Auto Platform · execution view Context → reason → govern → execute → record
Context
Auto GraphLiving enterprise context
Entities + relationshipsOperational truth
Memory + tracesEvery cycle deepens context
Intelligence
AI EmployeesPerceive · reason · act · learn
Auto ModelsCheapest capable model
Frontier reserveUsed only for hard reasoning
Control + execution
Auto PoliciesDeterministic gates
Auto RuntimeDurable execution
Audit + WorkbenchReplayable trace
The Auto Graph Auto Policies SLM cascade Auto Runtime 100% audit Sovereign
What happens when an Auto does a task

Six steps, every time.

A request comes in. The Auto looks it up in its map of the business, works it out using the cheapest capable AI for each step, checks it against your rules before doing anything that matters, carries it out on a system that never loses its place, and writes down every step. People handle only the exceptions. Here is that path.

01

AI Employees

Role-based multi-agentic workers coordinate through a four-loop harness: perceive, reason, act, learn.

02

SLM cascade

A compact classifier routes each step to the cheapest capable model.

03

Auto Policies

Authority, limits, and compliance are evaluated before consequential actions run.

04

Auto Graph

Entities, relationships, policies, memory, and execution traces ground the reasoning.

05

Auto Runtime

Long-running work executes durably and resumes without losing state.

06

Audit + Workbench

Every step is logged and replayable; exceptions surface with evidence and policy context.

H
People handle only the exceptions.High-impact decisions stay under human command.
Execution trace complete
The moat

The Auto Graph

01
One grounded queryGraph, vector, and relational context in a single store rather than a fan-out across systems.
02
Lower token movementTight graph context means fewer tokens shipped to any model per step.
03
Native audit contextPolicies and traces sit next to the entities they govern, so audit is native rather than reconstructed.
04
Compounding across AutosEvery Auto on the tenant shares the graph, so value compounds across functions instead of fragmenting.
Auto Graph
Entities
Relationships
Policy context
Execution traces
Operational memory
Process mining

Retrieval-augmented chatbots keep a cache of documents. An Auto keeps a graph of the enterprise. Entities, their relationships, the policies that bind them, the memory of prior decisions, and every execution trace live in one per-tenant substrate.

Why it is affordable to run

Don't use the most expensive brain for simple steps.

Every time an AI “thinks,” it costs money, measured in tokens. Many AI systems send every step to the largest, most expensive model, so the bill grows with every step in a process. That is the pattern Supervity calls tokenmaxing.

An Auto is smarter about it: most steps are simple sorting and extraction that a small, specialised model handles cheaply, and the large, expensive model is saved for the genuinely hard thinking. The result is roughly 60% fewer tokens per process.

~60%Fewer tokens per enterprise process than frontier-model agents.
Incoming process stepExtraction · classification · reasoning · judgement
Route intelligently
Small classifierCheapest capable route
Tier 1 · Router

Small classifier

A compact model classifies each step and routes it. Cheap, fast, and the reason the expensive models are rarely called.

Tier 2 · Domain reasoner

Fine-tuned SLM + adapters

A domain model carries the bulk of the work, specialised per tenant with lightweight adapters. The adapters are disposable, regenerable caches; enterprise knowledge lives in the Auto Graph.

Tier 3 · Frontier

Reserved for hard reasoning

The customer's own frontier-model contract is called only when the step genuinely needs it, which is where sovereign economics and margins hold.

The mechanism, in one line: deterministic code plus tight graph context plus a small model for the routine, with the large model held in reserve. The same economics let AIshore undercut outsourcing, and you can model it against your process.

Control plane + execution plane

Firm boundaries. Durable motion.

Autonomy only works in production when authority is deterministic and execution survives the real world. Auto Policies and Auto Runtime work as complementary planes.

P
Auto Policies

Control plane

Authority as a deterministic gate

Guardrails written as prompts are probabilistic; they mostly hold. An Auto evaluates authority, limits, segregation of duties, and compliance in a deterministic decision model that runs before any consequential action. The boundary is not a suggestion to the model. It is a gate the action must pass.

Proposed action
Gate
Approved execution
Plain-language authoringEvaluated pre-actionDeterministic
R
Auto Runtime

Execution plane

Durable execution and instant rollback

Enterprise work is long-running, spans systems, and must survive failure. The Auto Runtime executes durably and resumably, so a process that takes days does not lose state. Agent changes ship through a versioned lifecycle with instant rollback, so improving an Auto never risks the operation.

Run
Checkpoint
Resume
↻ Versioned changes · instant rollback
ResumableVersioned changesInstant rollback
100% audit

Every action logged. Every decision replayable.

Because policies and traces live in the Auto Graph next to the entities they govern, audit is not reconstructed after the fact. Every step an AI Employee takes, every policy decision, every human approval, and every model call is time-stamped and queryable. A regulator's question, “why did the system do this”, is answered by replaying the trace, not by interviewing the team.

Execution trace · AP-49281Replay mode
09:42Invoice receivedEntity context loaded from Auto GraphLogged
09:43Model route selectedDomain SLM selected for extractionLogged
09:44Policy evaluatedAuthority and threshold checks passedPassed
09:45Action executedState checkpoint written to RuntimeLogged
09:46Outcome recordedTrace + entity relationship deepenedComplete
100%Of actions logged and time-stamped
ReplayableEvery decision reconstructable from the trace
Pre-actionPolicy evaluated before consequential steps
Human-in-commandHigh-impact actions require approval
The industry standard

Software Autonomy Levels, L0 to L5.

Autonomous vehicles have SAE levels. Enterprise software needs the same shared language, so a CIO can say exactly how self-driving an operation is. Supervity proposes Software Autonomy Levels as that standard.

L0

Manual

People operate the software. Every step is human.

L1

Assisted

A copilot suggests; the human still does the work and every decision.

L2

Partial automation

Scripted tasks run alone, but break on exceptions and change.

L3

Conditional autonomy

AI Employees run whole processes and hand exceptions to a human. Where most Autos start.

Typical starting point
L4

High autonomy

The operation runs end to end under policy; humans govern by exception and objective. The Daikin Finance Auto operates here at 85% AI-first.

85% AI-first example
L5

Full autonomy

Self-optimising operations across functions on the Auto Graph, humans setting direction only.

Prove it on your process

Interrogate the architecture with an FDE.

The AutoPilot Bootcamp stands up a working Auto App on your data in three weeks. Bring your hardest process and your chief architect; leave with a running L3+ Auto and the trace to inspect.

Autonomous · Always Learning · Auditable