Onchain Eval Runtime

The deterministic runtime before onchain capital moves.

Determica turns live EVM state, event evidence, candidate calldata, forked simulations, branch comparisons, and policy checks into replayable decision records for treasuries, protocols, solvers, agents, and APIs.

Run live Ethereum eval Read technical docs

Live Ethereum eval

Swap preflight receipt

ready

Request
Forks
Policy
Decision
Receipt

finalized block4 forksreceipt ready

Capital decision

Advance the guarded repair; reject stale, denied-hop, and zero-minOut routes.

Eval facts

live state

input: 1 WETH -> USDC
state: Ethereum finalized
branches: 4 isolated forks
policy: denied contracts + slippage

Decision table

PASS one route. REJECT three unsafe branches.

Replayable receipt ready

Result

Candidate

USDC out

Reason

REJECT

agent_original_stale_quote

0.000000

would revert

REJECT

repair_denied_usdt_hop

2,122.189695

denied contract

REJECT

repair_zero_minout

2,122.25275

loose minOut

PASS

repair_signable_guarded

2,122.25275

policy_cleared

Docs / workflow guides

Runnable paths from primitives to eval workflows.

For humans

Studio

Turn manual checks before routing, approval, or signing into reusable eval workflows with replayable evidence.

For agents

Eval API

Let agents, bots, solvers, and approval systems call a deterministic eval before execution reaches a wallet or signer.

Agents everywhere

Capital now moves at software speed.

Agents, bots, solvers, keepers, and internal workflows can now propose routes, rebalances, allocations, and policy checks continuously.

Stablecoins and smart contracts make those proposals executable.

The signer is still accountable. Every serious capital-moving workflow needs deterministic eval before execution.

Proposal layer

Agents increase proposal volume.

Agents, bots, solvers, keepers, and internal workflows can propose routes, rebalances, allocations, and policy checks continuously.
Capital rail

Stablecoins make proposals executable.

Stablecoins, wallets, and smart contracts turn software proposals into settlement instructions that can move real capital.
Decision layer

Signers remain accountable.

Probabilistic systems can propose actions, but they should not become the authority on execution risk.

From manual review to always-on evals

Start with the decisions teams already check by hand.

Determica turns recurring capital-moving reviews into reusable eval workflows, replacing scattered scripts, RPC calls, fork links, dashboards, and risk notes with one replayable decision record before routing, approval, or signing.

Today

Repeated preflight is already happening.

Treasury routes, rebalances, allocations, vault actions, solver routes, agent proposals, governance execution, and approval checks already depend on manual evidence.

Scripts, RPC calls, fork links, dashboards, notebooks, and risk notes stitched together before routing, approval, or signing.

Determica

Turn the manual preflight into an eval workflow.

Pin state, fork candidate futures, compare outcomes, apply policy, reject unsafe paths, and return a replayable decision record.

Pinned block, SQL hash, policy output, rejected paths, evidence JSON, and receipt.

Expansion

Move from Studio review to automated runtime calls.

The same workflow becomes an Eval API path for agents, bots, solvers, CI checks, custody workflows, and repeated capital-moving APIs.

Humans review in Studio. Software calls the deterministic gate before execution reaches a signer.

Example workflows

Treasury route
Vault rebalance
Solver route
Liquidation path
Governance execution
Agent proposal

Solution kernel

determica

Agents, bots, solvers, and internal workflows can already propose routes, rebalances, allocations, transactions, and policy checks. The missing layer is deterministic preflight before those proposals reach wallets, signers, or approval systems.

Determica bounds each request, compiles it into a reviewable SQL Plan, runs forked EVM branches, and returns the decision record: ranked outcomes, rejected paths, policy output, pinned state, SQL hash, and receipt.

State drift is explicit. Each eval records the pinned block, candidate calldata, policy result, SQL hash, rejected branches, and receipt. Teams can require re-eval or reject signing when price, block, liquidity, route, or policy bounds move outside configured limits.

Studio and Eval API use the same kernel. Humans get a review surface. Software gets a deterministic gate.

Runtime

Local, hosted, or private.

Local WASM

Browser review

Studio checks with customer-controlled RPC.

Hosted Runtime

Managed gates

Warm state, branch comparison, audit records, API execution.

Private Runtime

Dedicated controls

Governed access, private cache, approval integrations.

Two paths in

One kernel for human and automated capital decisions.

Studio path

Human review surface

Operators design eval runs, inspect or modify SQL, compare branches, and attach evidence before approval.

Eval API path

Automated approval gate

Agents, bots, CI checks, and repeated workflows submit candidates and receive a deterministic decision record back.

Determica kernel

Analyze past state, simulate candidate futures, decide with evidence.

The same bounded path supports Studio review and Eval API automation.

Intent

Start with a capital decision.

Human request, agent proposal, bot candidate, CI check, or policy objective.
SQL Plan

Make the plan inspectable.

A bounded plan showing what will be read, forked, simulated, compared, and archived.
Runtime

Run against EVM state.

Use local checks, hosted cached execution, or private governed infrastructure.
Evidence

Return the decision record.

Ranked outcomes, rejected paths, policy output, pinned state, SQL hash, and receipt.

SQL is the reviewable plan for EVM state.

Capital workflows do not need another opaque action generator. They need a reviewable plan between probabilistic intent and deterministic execution.

Determica maps reads, logs, calldata, forks, simulations, policy checks, outputs, archives, and receipts into SQL so humans can inspect the plan and software can rerun it against pinned state.

Inspectable: Humans can review the plan before execution authority is granted.
Bounded: Reads, forks, simulations, policies, outputs, and archives are explicit.
Replayable: The same plan can be rerun against the same pinned state.
Governable: Agents can propose actions without becoming the authority on risk.

Live Ethereum eval

Live demo: eval an agent-proposed swap against Ethereum state.

Input: an agent proposes a WETH to USDC swap. Determica pins finalized Ethereum state, creates isolated forks, tests the stale agent route, tests repair routes, applies denied-contract and slippage policy, and emits a receipt. Output first, SQL second: the same pattern extends to rebalances, solver routes, governance, custody, and treasury workflows.

Eval workflow

Should this proposed swap advance?

An agent proposes swapping 1 WETH to USDC. Before any capital moves, Determica tests the proposal and safer alternatives against live chain state and policy, then returns a PASS or REJECT decision with evidence.

What gets evaluated

01

Pin live state

Lock every candidate to the same finalized Ethereum block.
02

Compare candidates

Evaluate the agent proposal against safer repair routes.
03

Run consequences

Execute each candidate in an isolated fork before capital moves.
04

Apply policy

Check execution success, gas, denied contracts, and slippage protection.
05

Return evidence

Show the route to advance, the rejected alternatives, and the reason each branch passed or failed.

Output

PASS one guarded repair. REJECT the unsafe branches.

Result	Candidate	USDC out	Reason
PASS	repair_signable_guarded	2,122.25275	policy_cleared
REJECT	agent_original_stale_quote	0.000000	would revert if signed
REJECT	repair_denied_usdt_hop	2,122.189695	denied contract touched
REJECT	repair_zero_minout	2,122.25275	slippage guard too loose

Runnable notebook

Inspect the SQL, then edit and rerun it.

Live demo

This demo executes from your browser against public Ethereum RPC. First run may take a moment while the engine loads state; after results land, the eval is editable and rerunnable.

Public RPC: Live Ethereum state
Editable after run: Change assumptions and rerun
Evidence output: Policy result + replayable receipt

-- Agent treasury eval preflight.

-- One pinned base state, one product branch per candidate, one stable run decision readout.

CREATE OR REPLACE TEMP TABLE pinned_block AS

SELECT number AS block_number, hash AS block_hash

FROM get_block($transport, 21000000);

CREATE OR REPLACE TEMP TABLE route_base AS

SELECT evm_create_sim_at(

1::UBIGINT,

block_number::UBIGINT,

block_hash::BYTES32,

'treasury_agent_preflight_base',

'cancun'::EVM_VERSION

) AS sim_id

FROM pinned_block;

CREATE OR REPLACE TEMP TABLE route_workflow AS

SELECT evm_execute_candidate_bundle(

{

"source_label":"agent_original_stale_quote",

"member":{"role":"subject"},

"branch":{"role":"candidate","label":"agent_original_stale_quote"},

"steps":[{"payload_kind":"bytecode","payload":{"address":"0x1111111111111111111111111111111111111111","bytecode":"0x00"}}]

{

"source_label":"agent_repair_denylisted_hop",

"member":{"role":"alternative"},

"branch":{"role":"candidate","label":"agent_repair_denylisted_hop"},

"steps":[{"payload_kind":"bytecode","payload":{"address":"0x2222222222222222222222222222222222222222","bytecode":"0x00"}}]

{

"source_label":"agent_repair_safe_direct",

"member":{"role":"alternative"},

"branch":{"role":"candidate","label":"agent_repair_safe_direct"},

"steps":[{"payload_kind":"bytecode","payload":{"address":"0x3333333333333333333333333333333333333333","bytecode":"0x00"}}]

}

]'::JSON,

(

'{"base_sim_id":' ||

(SELECT sim_id::VARCHAR FROM route_base) ||

',"selected_state_policy":{},"label":"treasury-agent-preflight"}'

)::JSON,

$route_policy::JSON,

'{"execution":{"gas":500000}}'::JSON

) AS result;

CREATE OR REPLACE TEMP TABLE route_scores AS

SELECT *

FROM (VALUES

-- 33 more lines load when JavaScript runs

Enable JavaScript to run these cells. The SQL previews above are still available for reference.

Enable JavaScript to run this sample in the notebook. The SQL preview above is still available for reference.

Pilot conversations

Bring one capital-moving workflow you already analyze by hand.

Determica turns the manual preflight you already trust into a reusable eval workflow: replay the relevant past, fork candidate futures, compare outcomes, apply policy, and return evidence before capital moves.

Best pilots start with one repeated workflow: a route gate, treasury rebalance, allocation review, agent proposal, policy check, or approval path that already depends on scripts, fork simulations, dashboards, or risk notes.

Prefer to write directly? Email [email protected].

The deterministic runtime before onchain capital moves.

Swap preflight receipt

Capital now moves at software speed.

Agents increase proposal volume.

Stablecoins make proposals executable.

Signers remain accountable.

Start with the decisions teams already check by hand.

Repeated preflight is already happening.

Turn the manual preflight into an eval workflow.

Move from Studio review to automated runtime calls.

determica

Runtime

One kernel for human and automated capital decisions.

Human review surface

Automated approval gate

Analyze past state, simulate candidate futures, decide with evidence.

Start with a capital decision.

Make the plan inspectable.

Run against EVM state.

Return the decision record.

Live demo: eval an agent-proposed swap against Ethereum state.

Should this proposed swap advance?

Bring one capital-moving workflow you already analyze by hand.