For the web apps your business runs on
The execution layer for web apps
For your agents · your systems · your team
01 — How it works
Taught once. Approved. Run on record.
uncannic carries out the work your team does in the web applications you already use — consoles, back offices, admin panels — including the ones with no API. It runs on your infrastructure, for your people and your AI agents.
Someone does the task, once
A person does it in the application the way they normally would. uncannic learns that action from the one demonstration: no scripts to write, no screen to read. An AI agent's first run can teach it too — proven on independent software.
A person approves what was learned
The learned action is shown as a plain card — what it presses, what it sets, on which record — and becomes runnable only when someone approves it with a passkey. A policy decides who may run it, where, and how often.
Then it runs, every time, on record
From then on the action runs through the application's own code, with no model call per run. Each run is confirmed from the application's own answer and written to a tamper-evident audit log you can verify.
02 — Performance
The engine's own time, measured apart.
What the engine itself spends on an action, measured apart from everything around it. The rest of every action belongs to two things outside the engine: the machine running it, and the application's own processing and response.
Where a write's time goes
Ten governed writes, each with a confirmation step, split by whose clock each millisecond ran on: the engine's, or the application's own processing and response.
Right after the page loads
After the page has settled for 4 s
Table view
| Run | When | The engine (ms) | The application (ms) | Whole action (ms) |
|---|---|---|---|---|
| 1 | Right after the page loads | 667 | 206 | 873 |
| 2 | Right after the page loads | 837 | 1438 | 2275 |
| 3 | Right after the page loads | 778 | 250 | 1028 |
| 4 | Right after the page loads | 649 | 240 | 889 |
| 5 | Right after the page loads | 786 | 259 | 1045 |
| 1 | After the page has settled for 4 s | 723 | 216 | 939 |
| 2 | After the page has settled for 4 s | 704 | 222 | 926 |
| 3 | After the page has settled for 4 s | 595 | 212 | 807 |
| 4 | After the page has settled for 4 s | 692 | 271 | 963 |
| 5 | After the page has settled for 4 s | 659 | 217 | 876 |
Reads, end to end
| What was read | Time | Over |
|---|---|---|
| A record's details, through the application's own data call | 147–151 ms | median of 11 reads, in each of two runs |
| A record's own page, read for the facts a person sees there | 248–262 ms | median of 11 reads, in each of two runs |
| The same facts with no person present, under a mandate | 331 ms | median of 8 recorded runs; 261–640 ms |
| The same read, called from Python | 391 ms | median of 5 recorded runs; 262–794 ms |
| The first read in a brand-new browser session | 264 ms | median of 7 recorded runs; 147–478 ms |
How it was measured. 2026-10-28, on a small local laptop with 8 GB of memory, acting on an unmodified third-party web application, served on the same laptop by a development web server. The engine's share is the time it spends on each action; it depends on the machine running it. The rest of each action's time is the target application's own processing and response, which depends entirely on that application and where it is hosted. These figures are a work in progress and will be updated as the engine matures. The film was recorded in real time on the same laptop while it also recorded its own screen at 60 frames a second, so every action in it runs slower than measured here.
03 — Where we stand
Our current stage, in the open.
What is proven, on what, and what is not yet — with the evidence each claim stands on.
Work in progress. These figures are rebuilt from our own records at each update and will change as the engine matures. Last updated 2026-11-06; last full verification of the release gate 2026-11-06.
284 conditions the engine must survive
Every condition ends one of two ways: the write lands exactly once, confirmed in the application's own record — or it is refused, by name. A silent wrong write is never an outcome. Each condition counts only at the level of its evidence.
By area, number of conditions
Table view
| Area | Proven on independent software | Proven on our own test applications | Partial | Open — the work list | A physical limit — refused, by name | All |
|---|---|---|---|---|---|---|
| How the application keeps its data | 1 | 12 | 0 | 7 | 0 | 20 |
| How a write travels — formats and transports | 12 | 9 | 1 | 18 | 0 | 40 |
| The page's lifecycle — loads, reloads, tabs | 26 | 4 | 2 | 7 | 0 | 39 |
| The network — slow, failing, lost | 6 | 11 | 0 | 2 | 0 | 19 |
| Faults in the browser and in the engine | 3 | 4 | 2 | 5 | 0 | 14 |
| Others acting at the same time | 1 | 7 | 0 | 1 | 0 | 9 |
| Time — long sessions, sleep and wake | 1 | 1 | 0 | 3 | 0 | 5 |
| Performance budgets | 11 | 0 | 0 | 4 | 0 | 15 |
| How the application's code is shipped | 5 | 0 | 0 | 0 | 0 | 5 |
| Frames and other extensions on the page | 3 | 3 | 1 | 8 | 0 | 15 |
| What our work costs the page | 4 | 0 | 0 | 1 | 0 | 5 |
| Who caused an action | 14 | 2 | 1 | 20 | 1 | 38 |
| Identity over time | 7 | 6 | 0 | 8 | 0 | 21 |
| How a write names its record and sends its values | 0 | 0 | 0 | 39 | 0 | 39 |
| All areas | 94 | 59 | 7 | 123 | 1 | 284 |
Selected conditions, by area
A selection for public disclosure, each with its current status. The full matrix is reviewed with design partners.
How the application keeps its data
- Data kept in a central storeProven · our tests
- Data kept in a background workerProven · our tests
- Real-time collaborative editing (operational transform)Proven · our tests
- Real-time collaboration built on CRDTsOpen
- Data and writes built inside WebAssemblyOpen
How a write travels — formats and transports
- JSON requestsProven · independent
- GraphQLProven · our tests
- Reads that return the application's own answer to the callerProven · independent
- Writes over WebSocketsPartial
- Binary formats — protobuf, gRPC-Web, MessagePack, CBOROpen
- A form for a record the open page does not showOpen
The page's lifecycle — loads, reloads, tabs
- A reload mid-sessionProven · independent
- A brand-new browser for every callProven · independent
- The application redeploying the same code, re-bundledProven · independent
- Navigation inside a single-page applicationProven · independent
- Several tabs of the same applicationProven · independent
- A tab the browser discarded or restoredProven · independent
- A frame from another origin of the same siteOpen
The network — slow, failing, lost
- Rate limits, server errors, hangs and redirectsProven · our tests
- A connection lost mid-writeProven · our tests
- An expired sessionProven · our tests
- Going offline and reconnecting mid-actionProven · our tests
- Packet lossProven · independent
- High network latencyProven · independent
- The browser's connection limit, taken by the application's own requestsProven · independent
Faults in the browser and in the engine
- The extension updated mid-sessionProven · independent
- A hostile page trying to reach the engineProven · our tests
- Pages with a strict content-security policyPartial
- The tab's process killed mid-actionOpen
- A machine clock off by minutesProven · independent
Others acting at the same time
- Many governed runs at onceProven · our tests
- Another person editing while an action runsProven · our tests
- The person's own text selection never overwrittenProven · independent
- Two actions on one record at onceOpen
Time — long sessions, sleep and wake
- Long sessions (soak testing)Open
- The machine sleeping and waking mid-sessionOpen
Performance budgets
- An action's time, dispatch to answer, held to a budgetProven · independent
- The memory the engine uses in the person's tabProven · independent
- An application whose own code keeps the page busyProven · independent
- A slower machine, every budget still heldProven · independent
How the application's code is shipped
- Minified production buildsProven · independent
- Modern module buildsProven · independent
- Pages enforcing Trusted TypesProven · independent
Frames and other extensions on the page
- An application embedded in a cross-origin frameProven · independent
- Other browser extensions running on the same pageProven · independent
What our work costs the page
- No keystroke delayed while the person typesProven · independent
- Multi-megabyte application bundles, at no felt costOpen
Who caused an action
- Content the person pastes or dropsProven · independent
- An action the person confirms in a browser dialogProven · independent
- A read under a mandate that releases only the named factsProven · independent
- The page's own background traffic, never taken for the person'sProven · independent
- Plain typing in editors that leave each key to the browser — refused, by nameLimit · refused by name
- An AI agent's first run as the teacherProven · independent
Identity over time
- Several editors on one page, each told apartProven · independent
- A record known by itself, never by its place in a listProven · our tests
- Identical code redeployed elsewhereProven · independent
Tested on independent software
- Commerce and content-management back officestheir own release packages, checksums verified, unmodified
- Project and task management toolstheir own releases, unmodified
- Four major rich-text editor frameworkstheir published packages, built as an application ships them
- Another browser extension on the same pagesits own published release, unmodified
- Recordings of live production applicationskept as they were served, replayed offline
- Live production applicationsa code-hosting service, an enterprise service console and an online document editor, each run in a person's own signed-in session
Open, in plain words
- Teaching on an overloaded test laptopSeen only when our 8 GB test laptop was short of memory (under 3 GB free): some runs did not catch the first demonstration. With memory to spare, none did in about 30 runs. The run stops and says so; nothing is written.
- The engine's own time per writeAbout 0.7 s of each governed write is the engine's own. Each step is now being measured, to cut it.
- A form for a record the open page does not showServer-rendered consoles where the record is not open on the page.
- Cloud browsersBuilt for browsers started per call: a brand-new session's first read in about a quarter of a second, and a licence seat that frees itself when the browser stops. Works today on a company's own Chromium fleet. Cloud browsers that accept an enterprise browser policy and custom extensions take the same setup, not yet run there; for the others, one setup step is in design.
- MCP over the networkAgents on the same machine call the MCP server today; over HTTP, next.
- The container packageBuilt. Its first end-to-end run is still ahead; the bare-Linux package has run end to end.
By design — not coming
- Chromium-based browsers only.
- CAPTCHAs and other bot checks are refused.
- A payment-card write needs a person, every time.
- When an application's code changes, its learned actions are refused by name and taught again — never a silent wrong write.
- Plain typing in rich-text editors that leave each keystroke to the browser is refused by name; pasting into them works.
04 — Security and governance
Governed by default.
The rules are part of the product, not settings to remember.
Only what the person could do
It acts inside the application as the signed-in person could. Forging attestations, extracting keys, impersonating another account or bypassing a security control cannot even be expressed.
Shapes, never secrets
It keeps the shape of an action, never its secret values: redaction by allow-list, failing closed.
A closed list of actions
No arbitrary code. Adding an action is a reviewed change.
One authority decides
Every action is authorized by a policy engine (Cedar). An error is a deny, never an allow.
A tamper-evident record
Every decision and run goes into a SHA-256 hash chain, written before the action runs. An action that cannot be recorded does not run.
Identity bound to the device
Each agent's credentials are bound to its own key (DPoP). Revocation is checked when a credential is issued and when it is used.
Approval and consent
Each application needs legal and review approval before anything acts on it; each person's consent is scoped and revocable. An agent with no person present acts only under a mandate a person grants with a passkey: the actions it names and the inputs each accepts, until it is withdrawn. Switched on per customer.
Fails closed
No durable state, no start. Anything unmatched is denied.
05 — Deployment and licensing
Yours to run.
uncannic is delivered as software you run yourself, under an offline licence — never as a service that holds your data.
On your infrastructure
The platform, the console, the browser extension and the MCP server all run on your machines or servers, and your agents call it through MCP or from Python. No phone-home, no telemetry, nothing of ours in your path.
Licensed offline
The licence is checked on your own machine and bound to one installation. Nothing is sent to us.
Self-serve
One command to install, one to update, one to roll back. The extension updates from your own server, by your browser policy.
Disclosed
A software bill of materials (SBOM) for every open-source component it ships.
The product, never the know-how
Release builds are minified, without source maps, and watermarked for each licensee.
Verified counterparts
Licensed to verified legal entities only, each one approved by us.
Distribution, built so far
- builtLicence and its enforcement
- builtWatermarked builds for each licensee
- builtThe package and its install — run end to end on Linux
- builtSelf-serve updates and rollback — run end to end on Linux
- nextThe ordering portal
- in progressCompany registration
The terms, in brief
- An 8-day evaluation window, then an annual licence. Cancel within the window and nothing is charged.
- Founding Partners: the first 20 licences, 25% off the first term, the price held for three renewals.
- For verified legal entities, each approved by us.
We are opening uncannic to a few design partners.
We are early, and we say so plainly: the engine is in active development while we complete our company's establishment. If there is a workflow your people or your agents run in a web application every day, we would like to hear about it.
business@uncannic.com