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
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.
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
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
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.
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.
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.
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.
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.
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.
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)
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
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.
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.
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.
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)
2
Simulate a policy
simulate_policy(record, config, at=...)
3
Reevaluate live
live_reevaluate(record, loop)
History and simulation never dispatch. Reevaluation is the only one that spends budget, and it never dispatches either.
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
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.
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.
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.
Before you go
Three things to copy, whatever you build with
Still to be proven
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.