Reusable computation for AI agents

Your agents shouldn’t solve the same problem twice.

Wont finds the work your AI agents keep repeating and turns it into a verified, instant path. When it isn’t sure, it hands the task back to your agent.

Use Wont → See how it works

Self-hosted · Python SDK · your agent stays in control

demo feed

refund_status_lookupcompiled1.6 ms
order_total_calccompiled1.7 ms
ticket_triagenew workto agent
refund_status_lookupcompiled1.5 ms
invoice_summaryunsureto agent

01The hidden tax on agent systems

Most of what your agents do,
they’ve done before.

Every run pays full price in model latency, tokens and orchestration, even when your agent has solved the same task many times.

Today

reasoncall toolsreasonanswer reasoncall toolsreasonanswer reasoncall tools…again

0 model calls on repeats

With Wont

new work→your agent repeated work→compiled path · instant

0 model calls on repeats

time

Seconds on answers you already know

Every repeat waits on model latency, tool calls and orchestration.

tokens

Paying for the same reasoning again

The work has the same shape every time. The bill arrives every run.

consistency

Same question, different answers

Re-deriving a result each time invites drift where you want none.

02Measured, not promised

Same answers. A thousandth of the time.

agent 1,365 ms

1.6 ms

Typical response time (p50)

agent 30 calls

Model calls on the compiled path

agent 30/30

30/30

Correct, with no accuracy traded for speed

naive matcher 9 wrong

0 wrong

On 35 tricky lookalike cases

agent

1,365 ms

wont

1.6 ms

Controlled benchmark · one supported workflow · 30 measured runs per lane · 35 adversarial cases for the lookalike test

03How it works

Wont learns your agents’ habits,
then proves them.

01
Observe
Wont records what your agent does. Prompts, responses and secrets are stripped out first, so only the safe shape of the work is stored.
02
Detect
It spots the same work recurring with new inputs. Each repeat adds evidence; one sighting is never enough.
03
Compile
The stable part becomes a fast, deterministic path: the groove that repetition wears in.
04
Verify
The path is checked against your agent’s own results before it is ever trusted to run.
05
Execute or abstain
Familiar, verified work takes the compiled path in milliseconds. Anything new or uncertain goes to your agent.

three agent runsreusable computation

run 1planlookup ordercheck policycompute refundwrite reply

run 2planlookup ordercheck policycompute refundwrite reply

run 3planlookup ordercheck policycompute refundwrite reply

Same steps, new inputs: compiled once, verified, reused.Fresh reasoning stays with your agent.

Not a cache. Not a router. Wont reuses the computation, not the answer, so new inputs still get correct results.

04The Reusable Computation Map

See exactly what your agents
are paying for twice.

Recurring workflows, how often they repeat, which are ready to compile, and every time Wont chose to step aside.

app.usewont.com / production

recurring workflows

runs that repeat

41%

compiled paths

fallbacks this week

model calls avoided

1,284

workflow	repeats	status	verification
refund_status_lookup	318	compiled	30/30 agree
order_total_calc	204	compiled	30/30 agree
invoice_summary	57	observing	collecting evidence
ticket_triage	23	stays with agent	novel reasoning

Unfamiliar input on refund_status_lookup · handed to your agent

Preview with illustrative data. The hosted dashboard ships with the public beta; today the same findings come from the SDK’s repetition report.

05What happens when Wont is wrong?

Wont earns the right to execute.

It never blindly replaces your agent. When anything is uncertain, the task goes to your agent: a slower answer, never a silent wrong one.

Verified first

A path is checked against your agent’s results before it can run.

Compare before you trust it

Shadow mode runs Wont alongside your agent and only compares. Early access.

Abstains when unsure

Unfamiliar or changed inputs go straight to your agent.

Read-only by design

No writes to production systems.

measured

0 wrong executions on 35 tricky lookalikes

A naive matcher executed 9 of them wrongly.

06Built for developers

Start with the traces you already have.

Run Wont next to your stack, send it your agent traces, and get a report of the work worth compiling.

1Install from the repository
2Start PostgreSQL and run the migrations
3Create a project and its API key
4Start the API, send traces, read the report

Self-hostedPython 3.12REST API + SDKYour data stays with you

The SDK ships as the reflex package today. The wont name is coming.

# 1 · install
pip install -e .

# 2 · database
docker compose up -d postgres
export DATABASE_URL="postgresql+psycopg://reflex:reflex_dev_only@localhost:5432/reflex"
python -m alembic upgrade head

# 3 · project + one-time API key
python -m examples.week7_bootstrap_project \
  --workspace demo --workspace-name "Demo" \
  --project support --project-name "Support" \
  --environment development

# 4 · API
python -m uvicorn apps.api.main:app --port 8000

import os
from reflex import Reflex

client = Reflex(
    api_key=os.environ["REFLEX_API_KEY"],
    base_url=os.environ["REFLEX_BASE_URL"],
)

# trace: a TraceIngestRequest from your agent run
client.traces.ingest(trace, workflow_version="support-v1")

report = client.repetition_report(limit=10)
print(report.repeated_family_count, report.repetition_coverage)

# the quickstart's six demo traces
scoped_execution_count     6
distinct_procedure_count   3
repeated_family_count      2
repeated_execution_count   5
repetition_coverage        5/6
top_families               3, 2

07Where it fits

Anywhere agents repeat themselves.

Repeated lookups

Status checks, record fetches, routine reads.

Deterministic calculations

Pricing, conversions and totals the model re-derives every time.

Stable routines

Multi-step procedures that keep the same shape.

Supported today: read-only lookups and deterministic calculations. More patterns in design-partner pilots.

08Questions

Does Wont replace my model?

No. Your agent handles all new work and anything uncertain. Wont only takes over work it has already verified.

What does it store?

A safe trace structure. Raw prompts, responses and credential-like values are stripped before anything is stored.

What if my workflows change?

Changed inputs or shapes fail Wont’s checks, so the task goes back to your agent automatically.

Does it support writes?

Not today. Wont is read-only by design.

Which frameworks and models work?

Any agent that can send traces through the SDK or REST API. Wont doesn’t depend on a specific model.

Can I try it without risk?

Yes. Start with the repetition report. It only reads the traces you send and never touches how your agent runs.

Find the computation your agents
shouldn’t be paying for twice.

Use Wont → Read the quickstart

wont /wōnt/ noun · one’s customary behaviour; habit.

Your agents shouldn’t solve the same problem twice.

Most of what your agents do, they’ve done before.

Seconds on answers you already know

Paying for the same reasoning again

Same question, different answers

Same answers. A thousandth of the time.

Wont learns your agents’ habits, then proves them.

Observe

Detect

Compile

Verify

Execute or abstain

See exactly what your agents are paying for twice.

Wont earns the right to execute.

Verified first

Compare before you trust it

Abstains when unsure

Read-only by design

0 wrong executions on 35 tricky lookalikes

Start with the traces you already have.

Anywhere agents repeat themselves.

Repeated lookups

Deterministic calculations

Stable routines

Find the computation your agents shouldn’t be paying for twice.

Most of what your agents do,
they’ve done before.

Wont learns your agents’ habits,
then proves them.

See exactly what your agents
are paying for twice.

Find the computation your agents
shouldn’t be paying for twice.