1 of 21

Applied AI Summit 2026, AI governance track

Governed Execution for AI Agents

Refusal, replay and audit-ready evidence in production

​

Muntaser Syed, Florida Institute of Technology

October 2026

2 of 21

A final answer hides the decisions that produced it

An agent works through model calls, retrievals, tool invocations and side effects. The transcript at the end does not say which resources were consumed, why a tool call was permitted, or whether a later reconstruction repeated the same execution.

Most governance programs answer those questions after the fact, from documents, dashboards and review meetings. The record they rely on was never designed to be checked.

1

Admission

Was this action in the declared, versioned set, with arguments that match its schema, under the policy state recorded at the time?

2

Accounting

Was the budget checked before the spend, and when it could not be, is the overrun recorded as an overrun rather than averaged away?

3

Evidence

Can a reviewer who does not trust us re-run the workflow offline and detect any change to the record?

A log answers none of these. A governed execution record is built to answer all three.

3 of 21

Structural, fail-closed, provable

The argument of this talk: governance survives contact with production when it is enforced at the point of execution, refuses when a precondition is missing, and produces evidence that can be verified offline by someone with no stake in the result.

Three open-source Python packages carry the argument, and each maps onto one of this summit's themes: testing and audit, validation, and monitoring.

pollard

PyPI 1.6.0

Governed execution trees: one identity for admission, execution, refusal and replay; registry firewall; transactional budgets; rolling seals.

Testing and audit

pollard-jev

PyPI 0.13

Typed decisions over timestamped evidence with validity windows. The model proposes; a deterministic, versioned policy disposes.

Validation

epicormic

PyPI 0.1.0

Provider drift detection on canary panels, with verdicts that become refusals, confirmations or gates inside pollard.

Monitoring

All three: MIT license, github.com/jemsbhai, pip install

4 of 21

pollard

Governed execution trees for AI agents: budget it, gate it, replay it.

A runtime primitive, not an agent framework. Your code keeps the loop, the model client, the tools and the prompts. pollard supplies the identity, the gates, the ledger and the evidence.

Python 3.10 or newer

Zero runtime dependencies in the core package

1.6.0 on PyPI

26 releases; a 1.0 stability covenant freezes identity and store contracts until 2.0

IEEE ICTAI 2026

Paper accepted; evidence pinned to a signed tag of pollard 1.0.5

MIT license

github.com/jemsbhai/pollard, with a CLI that verifies recordings offline

5 of 21

One identity for admission, execution, refusal and replay

The caller wraps a model or tool operation as a semantic step. Before it runs, pollard derives an identity from the canonical input and the parent step, evaluates the resource and action gates, and records the decision. After it runs, pollard settles the measured use and stores the result.

A refusal is a node. A result is a node. The replay of that result is the same node. Nothing has to be reconciled between a policy log, a cost report and a trace, because there is one tree.

Caller-owned�agent loop

Canonicalize�and identify

Budget and�action gates

Model or tool�operation

admit

Tree�store

refuse

settle

strict replay: stored result, no call

node = (parent, kind, attempt, input, result, metadata)

id = SHA-256( pollard/v1 || canonical(parent, kind, attempt, input) )

The result and the metadata never change an id. Floats and raw bytes are rejected from identity because their encodings are platform dependent, so the same program yields the same ids on Linux, Windows and macOS, and CI locks them.

Branching copies a cursor, rollback moves it to an ancestor, pruning marks a tip. None of these rewrites an existing node.

6 of 21

Structural gating, not content judgment

With a registry installed, a tool call cannot execute an arbitrary function. The runtime resolves the name and version against a declared ActionSpec, validates the arguments against its schema, records the specification digest and the registry digest, and only then runs the registered handler.

Anything else produces a refusal node, persisted before the exception reaches the caller. The handler never runs.

run.tool_call(name, version, args)

Unknown action

Version mismatch

Arguments fail the schema

Policy callback denies

Confirmation missing

Refusal node

Written to the tree before the exception is raised. It carries the blocked kind, a digest of the blocked payload, and the reason. The handler is never invoked, and the refusal is as much part of the audit record as a completed call.

Registered handler runs; spec and registry digests are recorded on the node

Dry run

Side-effectful actions are recorded without executing their handlers, so an intended action transcript can be reviewed before writes are allowed.

7 of 21

Refuse before the spend, and say so when you could not

Every meter supplies a precheck estimate. If the estimate shows a step would exceed its budget, pollard persists a refusal node and never invokes the function. Transactional stores reserve the estimate before execution and settle the measured charge afterwards, so concurrent workers share one exact limit.

Budget semantics stay honest about what can be controlled.

settled + reserved + this estimate <= limit

for every scope the step touches, established atomically in one store transaction

steps

depth

wall clock

tokens

USD

sliding windows

GPU energy, local only

Exact meters

While the completing owner keeps its lease, settled use cannot exceed the limit (Theorem 1). Reservations are leases: an expired owner that finishes late is reported separately, never folded into the zero-violation claim.

Estimated meters

Overshoot is bounded by the sum of estimate errors (Corollary 1). The bound does not turn an estimate into a cap; it names the quantity calibration has to control.

When the charge arrives after the fact

If the measured result exceeds the budget once the function has returned, that node stands: the spend already happened. Later steps are refused. The overrun is recorded as an overrun, with the fallback noted in metadata when provider usage is missing.

8 of 21

Evidence a stranger can verify offline

Each node id commits to its ancestry and identity payload. A rolling seal over the deterministic traversal commits to every node id, parent, kind, result digest and position.

Verification recomputes all of it before a subtree is replayed, sealed, exported or imported. A reference custody sink keeps the final digest outside the store it protects, and it refuses to share that store's file.

z0

z1

z2

z3

z_t

z_i = H( index, node id, parent, kind, result digest, z_i-1 ) published with the ordered entries; z_t is the digest a reviewer keeps

Offline CLI

pollard verify, seal, export and import work on a SQLite recording with no model, no credential and no network. Export writes an ordered manifest with its seal; import verifies the whole artifact before inserting a node.

Custody outside the store

SQLiteSealSink appends sequence, store id, root id, algorithm, digest, time and signer to a separate database and refuses to share the pollard store file. Key management and retention stay with the operator.

Content-free telemetry

OpenTelemetry spans carry kind, timing, outcome and selected digests. Trace and span ids are never part of semantic identity, so observability and the integrity boundary stay separate.

Stated limit

Tamper evident, not tamper proof. Whole-store replacement is detected only against a digest held outside the store. Mutable metadata is outside the seal by design.

9 of 21

Replay serves recorded results and never re-executes

record executes and stores. hybrid serves a stored result on an identity hit and records on a miss. replay never calls a step function, a registered handler or a live policy hook; a missing recording raises. Avoided charges are reported, not hidden.

The same recordings drive pytest in CI with one flag, so a governed workflow is re-run on every commit without a model in the loop.

record

Execute the function and store the result; the default.

hybrid

Serve a stored result when the computed node id already exists, otherwise execute and store.

replay

Never call a step function, handler or live policy hook. A missing recording raises MissingRecording. Ancestry is verified before any result is returned.

0 of 155

strict-replay observations entered the wrapped operation, checked with a sentinel that fails if called (study E3)

930

ancestry-unsafe aliases produced by an argument-only cache on the same workload: the cost of leaving the parent out of the key

Revalidation, not resampling

run.revalidate_model_call verifies the golden recording, stores a new budgeted live observation, and writes value-free comparison evidence. The golden node is never replaced; the pytest fixture switches modes with --pollard-mode.

10 of 21

One governed run, start to finish

Forty lines of Python against the published wheel: a registered tool, one offline model call, an unknown action refused, a token precheck refused, a seal, then strict replay with a sentinel client that raises if it is ever reached, and pollard verify on the SQLite ledger.

Live model calls: one before replay, still one after it. Every node id on screen is reproducible on any machine.

11 of 21

What the signed studies measured

Evidence in the ICTAI paper is pinned to pollard 1.0.5 at commit 64d345f7. The package is at 1.6.0; the releases since add stores, provider adapters and governance meters, not new claims.

Deterministic studies ran from a signed tag. Every prespecified terminal outcome is retained, including the ones that fell outside a theorem's premise.

6,400,000

seeded transitions per replica, two replicas, zero invariant violations, all ten preregistered ablations exposed their witness (E1)

0 of 122

retained-lease PostgreSQL groups exceeded an exact limit; each weaker counter overshot by 280 units under the same barrier schedule (E2)

0 calls

made by strict replay in 155 observations; the argument-only cache control produced 930 unsafe aliases (E3)

1,470 of 1,470

semantic mutations detected by an independent verifier, with zero alarms on 120 permitted metadata controls (E6)

360 pairs

LangGraph, OpenAI Agents, pydantic-ai and MCP matched the manual reference; 720 trees verified; ablated boundaries exposed by an external proxy (E7)

4.36 USD

conservative spend of the hosted study under a 7.00 USD hard stop; every completed trial verified; reported as integration evidence, not utility equivalence (E5)

12 of 21

pollard-jev

The model proposes. The policy disposes.

A Python companion to pollard that turns timestamped observations and permitted choices into a governed decision, a bounded action and an outcome record. The first milestone runs entirely offline.

0.13 on PyPI

Companion package; pollard 1.6.0 supplies the ledger, budgets, registry and verification

Offline by design

No credentials, no model weights, no GPU needed for the demo and the test suite

Typed contracts

Observations, requests, provider results, policy outcomes and actions are validated Pydantic models that round-trip

Deterministic policy

Versioned, configurable thresholds; abstention is a designed outcome, never scored as an error

13 of 21

A decision is more than a step

A request carries timestamped observations with units, validity windows and explicit unknowns, a question, and the permitted choices with bounded integer parameters. A provider returns scores or a proposal.

A deterministic, versioned policy decides whether execution is permitted, more evidence is needed, or the system defers. Every stage lands in one linked record with provider identity, policy version and pollard node ids.

Observations�with validity

Provider�scores or proposal

Policy�decides

Bounded�action

Linked�record

Evidence support

Action feasibility

Task utility

Three separate questions. Support says the evidence backs the choice; feasibility says the robot can do it now; utility is the caller's question and hypotheses, not a trained predictor.

accept

supported, feasible, fresh: dispatch the bounded skill with the proposed parameters

need evidence

conflicting, missing, duplicate, invalid or future-dated readings block action

defer

evidence expired during inference, budget exhausted, provider failure or malformed output

Scores keep their semantics. Independent support or entailment scores are never normalized into an action distribution, and no score is read as a probability of physical success. Malformed or non-finite outputs are rejected, not treated as confidence.

14 of 21

Evidence expires, and the check happens at dispatch

Six scenarios in the offline demo. The registered handler rechecks policy, freshness, cancellation and the monotonic deadline immediately before dispatch, so evidence that expires during inference defers and a late model response cannot act after a timeout.

A second action in the same batch needs new observations. The budget counts logical provider attempts, not tokens or joules, and the record says which.

Scenario

Proposal

Policy

Simulated action

Fresh, coherent observations

continue

accept

move 20 cm

Conflicting observations

inspect

need evidence

none

Missing evidence

inspect

need evidence

none

Evidence expires during inference

continue

defer

none

Request budget exhausted

none

defer

none

Provider failure

none

defer

none

The same shape, outside robotics

Observation: any timestamped input with a validity window. A lab value, a vendor attestation, a retrieved document under a decay rule, a balance as of a cutoff.

Choices: a finite, audited action set with bounded parameters. Acceptance never widens it.

Policy: deterministic, versioned, replayable over the recorded evidence. The model proposes; it does not dispose.

A design pattern, stated as one. The implemented policy and skills are specific to the robot demonstration.

15 of 21

The offline demo, verbatim

pollard-jev demo --output artifacts, then pollard verify on the ledger it wrote. Six scenarios, synthetic scores, simulated actions, uniquely named JSONL records, 26 nodes across six runs, no findings.

The header says what the numbers are: demonstration thresholds, a budget unit of one logical provider attempt, synthetic scores. The record says the same thing in its fields.

16 of 21

Three operations that governance teams confuse

A record can be inspected, re-judged, or re-asked, and those are different things with different costs and different claims.

pollard-jev keeps them apart in the API and in the documentation, because a changed policy outcome on an old record does not reveal what the consequences of a different action would have been.

1

Inspect history

inspect_history(path)

  • Loads recorded events only.
  • No provider, no dispatcher, no new inference.
  • Reads the JSONL export or the pollard ledger as written.

2

Simulate a policy

simulate_policy(record, config, at=...)

  • Evaluates recorded observations and provider output under a specified policy and time.
  • No model call, no dispatch, no replay of the budget ledger or cancellation state.
  • A changed action does not reveal what its consequences would have been.

3

Reevaluate live

live_reevaluate(record, loop)

  • An explicit new provider invocation that consumes the loop's request budget.
  • Writes a new record linked to the original; original timestamps are preserved; dispatch is always disabled.
  • Old evidence normally defers at today's time. Historical records are never overwritten.

History and simulation never dispatch. Reevaluation is the only one that spends budget, and it never dispatches either.

17 of 21

epicormic

Governance does not end at deployment.

Provider drift detection and containment for pollard-governed systems. Epicormic shoots are the ones that regrow after a tree is pollarded: behaviour that reappears, or changes, after a baseline has been pinned.

0.1.0 on PyPI

First functional release, September 2026; 100 percent line coverage; MIT

One dependency

pollard 1.6 and nothing else; the statistics are standard-library Python

Canary panels

A fixed set of probe requests observed N times per probe, per window, inside a pollard tree

Verdict to lever

A drift verdict becomes a refusal node, a forced confirmation or a contract gate

18 of 21

Drift, defined so the claim can fail

Each window observes the panel N times per probe inside a pollard run, so every observation is content-addressed, budgeted, sealed and resumable: rerunning a window dispatches only the samples that are missing.

Scorers reduce results to value-free signals. The null hypothesis is that baseline and current samples of each probe are exchangeable; the verdict reports the evidence against it and never names a cause.

One window, one pollard run

ROOT epicormic/<panel>/<window>

window header: panel digest, contract, sampling

probe branch (attempt = probe index)

sample branch (attempt = sample index)

model_call probe payload

Identity never contains floats: temperature and top_p are committed as decimal strings in the panel digest and decoded only at dispatch.

Tests, per probe and pooled

Per probe: Fisher's exact test for indicators, Mann-Whitney U with Cliff's delta for scalars, Benjamini-Hochberg across probes.

Pooled: a stratified permutation test on mean Cliff's delta, labels permuted within probe, Holm across scorers.

Across windows: CUSUM and Page-Hinkley as baselines, and a betting e-process that is valid at any stopping time.

unknown

no baseline, or too few samples to judge

drift

a pooled test rejects after Holm, or a sequential detector alarms

warning

a per-probe test rejects with a material effect, or a detector is halfway there

stable

otherwise

Evaluated in that order. contract_changed is recorded separately, so a declared migration is never confused with a silent change behind a fixed model name.

19 of 21

A verdict becomes a refusal, not a dashboard

Three levers plug into pollard's fail-closed hooks and read the monitor's latest verdict from the store at every call. The verdict is value-free by construction: probe ids, node ids, digests, statistics, and nothing derived from result text.

Containment is forward-looking. Nothing is rolled back, and a person decides what happens next.

1

DriftMeter

Refuses model calls while the monitor is in a listed state. The refusal node names the monitor, the verdict node and the window, so the audit record explains itself.

2

DriftPolicy

Maps the state to allow, confirm or deny for registered tool calls; by default only side-effectful tools are affected, and drift forces a confirmation.

3

ContractGate

Refuses calls bound to an execution fingerprint other than the acknowledged one, listing the differing fields: provider, model revision, SDK, adapter, environment.

Gating a pipeline

epicormic verdict exits 0 stable, 2 warning, 3 drift, 4 unknown. A pytest marker, epicormic_gate, fails a test before its body runs when the ledger state is in the fail set. Verdicts export as JSON-LD with jsonld-ex provenance annotations, a Subjective Logic opinion for fusion, and an integrity digest a reader checks before trusting the document.

20 of 21

Ninety seconds, no credentials

Three windows on a seeded mock provider. Week 2 is a second instance with no injected change: sampling variance alone does not trip the test. Week 3 matches the baseline forty percent of the time and the stratified permutation test rejects.

The panel digest and the verdict node ids are the same on every platform, because the mock is seeded and every record is content-addressed. Both verdicts are appended to the monitor's chain as value-free evidence and recompute from the observations alone.

21 of 21

Before you go

Three things to copy, whatever you build with

  • One identity for the policy decision, the charge and the evidence, so nothing has to be reconciled.
  • Refusal as a first-class record. What was not done, and why, is audit evidence.
  • A final digest held outside the system that produced it, and a verifier that runs with no credentials.

Still to be proven

  • epicormic: pre-registered EXP-A to EXP-E, including a 28-day hosted canary across four provider families with a declared model switch on day 15 and a local silent-change arm.
  • pollard-jev: recorded-sensor evaluation, process-level inference termination, measured energy with a meter rather than a proxy.
  • pollard: the same signed discipline applied to 1.6 and to the native Rust and Node cores.

pip install pollard pollard-jev epicormic

github.com/jemsbhai/pollard

github.com/jemsbhai/pollard-jev

github.com/jemsbhai/epicormic

muntaser.ai msyed2011@my.fit.edu

Paper: Pollard, governed semantic execution trees, IEEE ICTAI 2026, accepted.