uncannicالعربيةbusiness@uncannic.com

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.

01 · Teach once

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.

02 · Approve

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.

03 · Run on record

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.

0
model calls per run, once an action is learned
0.70s
the engine's own time for a governed write with a confirmation step — median of 10 runs (0.60–0.84 s)
0.21–1.44s
the rest of the same writes — the application's own processing and response, which the engine does not control
0.15s
a read, end to end, the application's own response included — median
3 → 27
demonstrations → runs with nobody touching them
0
duplicate or wrong writes — every write checked against the application's own records

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

Run 1
0.87 s
Run 2
2.28 s
Run 3
1.03 s
Run 4
0.89 s
Run 5
1.05 s

After the page has settled for 4 s

Run 1
0.94 s
Run 2
0.93 s
Run 3
0.81 s
Run 4
0.96 s
Run 5
0.88 s
0.0 s0.5 s1.0 s1.5 s2.0 s2.5 s
Table view
RunWhenThe engine (ms)The application (ms)Whole action (ms)
1Right after the page loads667206873
2Right after the page loads83714382275
3Right after the page loads7782501028
4Right after the page loads649240889
5Right after the page loads7862591045
1After the page has settled for 4 s723216939
2After the page has settled for 4 s704222926
3After the page has settled for 4 s595212807
4After the page has settled for 4 s692271963
5After the page has settled for 4 s659217876

Reads, end to end

What was readTimeOver
A record's details, through the application's own data call147–151 msmedian of 11 reads, in each of two runs
A record's own page, read for the facts a person sees there248–262 msmedian of 11 reads, in each of two runs
The same facts with no person present, under a mandate331 msmedian of 8 recorded runs; 261–640 ms
The same read, called from Python391 msmedian of 5 recorded runs; 262–794 ms
The first read in a brand-new browser session264 msmedian 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.

PlatformChecking… StageEarly access — design partners CompanyIn establishment PricingNot published yet
284
conditions tracked, each to end proven or refused by name
94
proven on independent software, unmodified
59
proven on our own test applications
123
open — the work list, in plain sight

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.

9459123

By area, number of conditions

How the application keeps its data
20
How a write travels — formats and transports
40
The page's lifecycle — loads, reloads, tabs
39
The network — slow, failing, lost
19
Faults in the browser and in the engine
14
Others acting at the same time
9
Time — long sessions, sleep and wake
5
Performance budgets
15
How the application's code is shipped
5
Frames and other extensions on the page
15
What our work costs the page
5
Who caused an action
38
Identity over time
21
How a write names its record and sends its values
39
051015202530354045
Table view
AreaProven on independent softwareProven on our own test applicationsPartialOpen — the work listA physical limit — refused, by nameAll
How the application keeps its data11207020
How a write travels — formats and transports129118040
The page's lifecycle — loads, reloads, tabs26427039
The network — slow, failing, lost61102019
Faults in the browser and in the engine3425014
Others acting at the same time170109
Time — long sessions, sleep and wake110305
Performance budgets11004015
How the application's code is shipped500005
Frames and other extensions on the page3318015
What our work costs the page400105
Who caused an action142120138
Identity over time7608021
How a write names its record and sends its values00039039
All areas945971231284

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.

01

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.

02

Shapes, never secrets

It keeps the shape of an action, never its secret values: redaction by allow-list, failing closed.

03

A closed list of actions

No arbitrary code. Adding an action is a reviewed change.

04

One authority decides

Every action is authorized by a policy engine (Cedar). An error is a deny, never an allow.

05

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.

06

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.

07

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.

08

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.

Licensing and Distribution Terms · Acceptable Use Policy

uncannic

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