agent-invariant-eval
Deterministic, fail-closed governance and evaluation for multi-agent workflows. No LLM judge in the loop.
agent-invariant-eval wraps any agent loop (LangGraph, CrewAI, or a raw API loop) and enforces
hard invariants on its inputs, tool calls, routing and final output. Every check is plain
Python: regular expressions, checksums, exact decimal comparison and graph analysis. The same
trace always produces the same verdict.
[payment_dispute] verdict=block blocked_at=output
PASS no_pii: no PII found
PASS pci_compliant: no PAN or CVV found
FAIL numeric_grounding: 1 monetary figure(s) not found in tool payloads
evidence: ungrounded figure: $2,199.90
PASS valid_span_dag: span graph is a valid DAG
PASS no_routing_loops: 2 hop(s), no runaway routing
PASS no_swallowed_tool_failures: no unhandled tool failures
# InvariantViolation raised: the hallucinated refund never reaches the caller.
It does three jobs:
- Runtime gate. Block a run the moment it breaks an invariant (including pre-execution checks on tool inputs).
- Benchmark. Replay one dataset across model configurations and report pass rate, cost and p95 latency with a Pareto optimal recommendation.
- Telemetry. Emit verdicts and trajectory metrics as OpenTelemetry GenAI spans, to a JSON Lines file or over OTLP.
Install
pip install agent-invariant-eval # core library
pip install "agent-invariant-eval[all]" # core + CLI + OTLP exporter
To run the test suite and bundled example from source:
git clone https://github.com/sankaranainar-p/agent-invariant-eval.git
cd agent-invariant-eval
pip install -e ".[dev]"
pytest
python examples/payment_dispute_agent/run_eval.py
Core dependencies are pydantic, opentelemetry-api, and opentelemetry-sdk. The CLI (typer)
and OTLP exporter (opentelemetry-exporter-otlp-proto-http) are optional extras ([cli], [otlp]).
Requires Python 3.11 or newer.
Quickstart
Context manager
from agent_eval import EvaluationSession, InvariantViolation, default_registry
registry = default_registry(max_latency_ms=6000, max_tokens=20000)
try:
with EvaluationSession("dispute", invariants=registry, model="my-model") as session:
session.set_input(user_message) # input gate runs here
with session.agent("triage") as step: # invoke_agent span
plan = call_model(user_message)
step.set_tokens(input_tokens=350, output_tokens=60)
with session.tool("ledger.get_transaction", input={"id": "TXN-1001"}) as call:
call.set_output(ledger.get("TXN-1001")) # span gate runs on exit
session.set_output(answer) # output gate runs on exit
except InvariantViolation as violation:
print(violation.report.summary()) # the answer was never released
Decorator
from agent_eval import evaluate_agent, EvaluationSession
@evaluate_agent(invariants=registry)
def answer_dispute(message: str, session: EvaluationSession) -> str:
with session.tool("ledger.get_transaction") as call:
call.set_output({"amount": 42.50})
return "A refund of $42.50 has been issued."
answer_dispute("Refund TXN-1001") # returns the answer, or raises InvariantViolation
answer_dispute.last_report # EvalReport of the most recent call
The call arguments become the trajectory input and the return value becomes the final output.
The session parameter is optional; code deeper in the stack can call current_session().
Plain functions, async def functions, generators and async generators are all supported.
Under concurrent requests, read the report with with_report, which is race free.
last_report is one shared slot and is only reliable in single threaded use.
result, report = answer_dispute.with_report("Refund TXN-1001")
Streaming
A generator agent is evaluated as a whole stream. The joined chunks are the final output.
@evaluate_agent(invariants=registry) # stream="buffer" is the default
def stream_answer(message: str):
yield "A refund of "
yield "$42.50 has been issued."
| Mode | Behaviour | Guarantee |
|---|---|---|
stream="buffer" (default) |
Consume the stream inside the session, run the output gate, then yield the chunks | Fail closed. A blocked run releases nothing |
stream="passthrough" |
Yield chunks live, run the output gate when the stream ends | The violation is raised after the last chunk. Text is already out |
A plain function that returns a generator or coroutine object is rejected with a TypeError,
because the session would close before any work happened. Decorate the generator itself.
Single assertions
Each assert_* factory returns an invariant that can also be called directly:
from agent_eval import assert_no_pii, assert_pci_compliant
assert_no_pii()("contact jane.doe@example.com") # raises InvariantViolation
assert_pci_compliant()("card ending 1111") # passes
Monitor mode
Pass enforce=False to collect a report without raising. Use it to measure a workflow before
turning enforcement on.
Architecture
your agent loop (LangGraph / CrewAI / raw API)
|
@evaluate_agent or with EvaluationSession() decorators.py
|
records Span objects into a Trajectory schemas.py
|
+-----------------------+------------------------+
| INPUT gate | SPAN gate | OUTPUT gate
| on set_input() | on span open & close | on exit / finalize()
+-----------------------+------------------------+
|
InvariantRegistry (fail closed) invariants/base.py
| |
compliance.py topology.py
no_pii, pci_compliant, valid_span_dag, no_routing_loops,
numeric_grounding no_context_bloat, sla_bounds,
no_swallowed_tool_failures
|
EvalReport
| |
TelemetryEmitter FrontierRunner
telemetry/otel_exporter.py benchmark/frontier.py
JSON Lines file, OTLP pass rate, cost, p95, Pareto table
Data model
A Trajectory is a list of Span objects linked by parent_id. Parent links must form a DAG
(a forest). Three span kinds exist, named after the OpenTelemetry GenAI operations:
invoke_agent, execute_tool and chat.
Agent to agent routing is derived from the start order of agent spans. That routing graph may contain cycles even though the span graph cannot, and the loop analyzer works on it.
Fail closed
Anything other than a clean, explicit pass is a failure:
| Situation | Outcome |
|---|---|
| An invariant raises an exception | Recorded as a failed, blocking assertion |
| An invariant returns the wrong type | Failed |
| The registry is empty | Failed (registry_not_empty) |
| The wrapped agent raises | Run fails (agent_completed_without_error), exception propagates |
A blocking invariant fails with enforce=True |
InvariantViolation is raised, output is not returned |
| Telemetry export fails | Logged. The verdict is unchanged |
Invariants
| Name | Factory | Stages | What it asserts |
|---|---|---|---|
no_pii |
assert_no_pii() |
input, span, output | No SSN, ABA routing number, email or high entropy secret in any payload |
pci_compliant |
assert_pci_compliant() |
input, span, output | No Luhn valid PAN (13 to 19 digits) and no CVV pattern |
numeric_grounding |
assert_numeric_grounding() |
output | Every monetary figure in the answer exists in a tool output |
sla_bounds |
assert_sla_bounds(max_latency_ms, max_tokens) |
span, output | Latency and token budgets |
valid_span_dag |
assert_valid_dag() |
span, output | Unique span ids, known parents, no parent cycles |
no_routing_loops |
assert_no_routing_loops(max_hops) |
span, output | Handoffs within max_hops, no directed handoff taken more than max_edge_repeats times |
no_context_bloat |
assert_no_context_bloat() |
span, output | Input token growth across handoffs within max_growth_factor of a floored baseline |
no_swallowed_tool_failures |
assert_no_swallowed_tool_failures() |
output | Every failed tool call was retried, handled or acknowledged |
Detection details:
- SSN. Formatted
ddd-dd-ddddwith the structural rules (area not 000, 666 or 9xx; group not 00; serial not 0000). A bare nine digit number counts only next to an SSN keyword. - Routing number. Nine digits with a valid Federal Reserve prefix, the ABA 3-7-1 checksum,
and a routing keyword (routing, ABA, RTN) just before it. One in ten random nine digit ids
passes the checksum alone, so the keyword is required by default. Use
assert_no_pii(require_routing_context=False)to flag on the checksum alone. - Incremental & pre-execution scanning. When a span opens with an
input,Stage.SPANinvariants run before thewithblock executes (blocking tool side effects on violating inputs). When the span closes, only its new payloads are scanned. The final pass scans everything once more for the report. - Secrets & allowlists. Detects known API key prefixes (AWS
AKIA/ASIA, GitHubgh[pousr]_, Stripesk_live_/rk_live_, Slackxox[baprs]-) plus tokens of 24 or more characters that mix letters and digits with Shannon entropy of at least 4.0 bits per character (hex strings and UUIDs are skipped). Useallowed_domains={"company.com"}andignore_keys={"trace_id"}to exempt known corporate domains or metadata keys. - PAN. Digit runs of 13 to 19 digits, with optional spaces, dashes or dots, that pass Luhn.
A PAN embedded in a longer run is found by testing group aligned sub runs. Pass
assert_pci_compliant(require_known_bin=True)to restrict matches to major card network IIN/BIN prefixes and cut false positives on 16-digit IDs. - Grounding. Figures such as
$1,234.56,USD 50,12.5 dollars,99 cents,$1.2k,JPY 5000,₹1,00,000andC$20are parsed toDecimaland matched exactly against numbers in tool outputs. Numeric JSON leaves always count. A number inside a string counts only when it stands alone, so"TXN-1001","2026-10-03"and"12:30"ground nothing.ground_from_strings=Falserestricts grounding to numeric leaves. Tool inputs do not ground a figure by default, because the model wrote them. Derived figures (a sum the model computed) fail by design: have a tool compute them. Matching is on magnitude, so a ledger entry of-42.50grounds "a refund of $42.50". The currency itself is not compared. - Routing loops. Repeated directed handoffs are counted, not node visits. A supervisor that
delegates to three workers (S, A, S, B, S, C) repeats no edge and passes. A ping pong
(S, A, S, A) repeats S to A and is blocked. Raise
max_edge_repeatsfor a bounded review loop, or setmax_visits_per_agentfor a hard cap per agent. - Context bloat. Growth is the peak input tokens over the first step, with the baseline
floored at
min_baseline_tokens(500). A 50 token router followed by a 300 token prompt is not bloat. - Swallowed failure. A tool span with error status, or an output payload carrying an
errorkey, that is not followed by a successful call to the same tool, is not markederror.handled, and is not acknowledged in the final answer. Acknowledgement is a text heuristic that accepts inability phrases only ("we were unable to", "could not retrieve", "try again"). Apologies do not count.allow_acknowledgement=Falseturns the heuristic off and leaves only the structural signals. - Token accounting. A parent span that repeats the usage of its children (a common
framework roll up) is counted once. See
Trajectory.token_attribution().
All evidence attached to results is masked (***-**-6789, ************1111, j***@example.com).
Writing your own invariant
from agent_eval import BaseInvariant, Stage
class RefundCap(BaseInvariant):
name = "refund_cap"
stages = frozenset({Stage.OUTPUT})
def check(self, trajectory, stage):
for span in trajectory.tool_spans():
if span.tool_name == "refund.issue" and span.input["amount"] > 500:
return self.fail(stage, "refund above 500 needs human approval",
span_ids=[span.span_id])
return self.ok(stage)
registry.register(RefundCap())
check must be a pure function of the trajectory. It runs on partial trajectories at the
input and span stages, so it has to tolerate missing spans and a missing output.
Framework integration
The session has no framework dependency. Use the context managers where you own the loop, or
record_span where the framework owns it and gives you callbacks.
from agent_eval import Span, SpanKind, current_session
def on_tool_end(tool_name, tool_input, tool_output, started_ns, ended_ns):
current_session().record_span(Span(
kind=SpanKind.TOOL, name=f"execute_tool {tool_name}", tool_name=tool_name,
input=tool_input, output=tool_output, start_ns=started_ns, end_ns=ended_ns,
))
- LangGraph. Decorate the function that calls
graph.invoke, and opensession.agent(node_name)inside each node (or record spans from a callback handler). - CrewAI. Decorate the function that calls
crew.kickoff, and record spans from the step and task callbacks. - Raw API loop. Wrap each model call in
session.llm(model)and each tool insession.tool(name).
Parallel branches are safe with asyncio.gather, asyncio.TaskGroup and asyncio.to_thread:
the open span stack is context local, so each branch attaches to the span that was open when it
started. Plain threads do not inherit context, so pass parent_id there:
with session.agent("supervisor") as parent:
pool.map(lambda q: run_tool(q, parent_id=parent.span.span_id), queries)
These are integration patterns, not shipped adapters. The repository does not import either framework and has not been tested against a specific version of them.
Benchmark: cost to performance frontier
A dataset is a JSON Lines file. Each row names the verdict a correct system produces:
{"id": "nominal-refund", "input": {"message": "Refund TXN-1001", "transaction_id": "TXN-1001"}, "expect": "pass"}
{"id": "ssn-in-prompt", "input": {"message": "My SSN is 123-45-6789"}, "expect": "block", "expected_violations": ["no_pii"]}
A case passes when the verdict equals expect and every invariant in expected_violations
fired. So block rows test the governance layer, and pass rows test the model: a weaker
model that hallucinates an amount gets blocked on a row that expected a clean pass.
from agent_eval.benchmark import FrontierRunner, ModelConfig, load_dataset
models = [
ModelConfig(name="large", input_cost_per_mtok=15.0, output_cost_per_mtok=75.0),
ModelConfig(name="small", input_cost_per_mtok=0.25, output_cost_per_mtok=1.25),
]
def run_agent(case, model, session): # drive your real workflow with `model`
...
return answer
report = FrontierRunner(run_agent, invariants=registry, min_pass_rate=0.9).run(
load_dataset("suite.jsonl"), models
)
print(report.to_markdown())
Output of the bundled example (fictional models and prices, simulated latency):
| Model | Pass rate | Passed | Total cost (USD) | p95 latency (ms) | Pareto optimal | Recommendation |
|---|---|---|---|---|---|---|
| frontier-xl | 100.0% | 10/10 | 0.305250 | 11200 | yes | viable |
| balanced-m | 90.0% | 9/10 | 0.061050 | 9900 | yes | recommended |
| balanced-m-legacy | 90.0% | 9/10 | 0.081400 | 10400 | no | dominated |
| distilled-s | 50.0% | 5/10 | 0.005088 | 9320 | yes | below 90% pass floor |
The frontier maximises pass rate and minimises total cost and p95 latency. The recommendation
is the cheapest frontier model at or above min_pass_rate. If none clears the floor, the
highest pass rate wins. The p95 is nearest rank. The high p95 above comes from the one case
that simulates a degraded ledger for every model.
Async agents, concurrency and mixed model pricing:
from agent_eval.benchmark import ModelPrice
async def run_agent(case, model, session): ... # async runners are supported
runner = FrontierRunner(run_agent, invariants=registry, max_concurrency=8)
report = runner.run(cases, models) # worker threads
report = await runner.arun(cases, models) # tasks on your event loop
mixed = ModelConfig(
name="small-triage-large-resolution",
input_cost_per_mtok=3.0, output_cost_per_mtok=15.0, # default for unlisted models
pricing={ # keyed by the model set on each span
"small": ModelPrice(input_cost_per_mtok=0.25, output_cost_per_mtok=1.25),
"large": ModelPrice(input_cost_per_mtok=15.0, output_cost_per_mtok=75.0),
},
)
Results keep dataset order at any concurrency. Use arun when the agent shares loop bound
clients.
The same run from the command line. --models takes a JSON file or a module:attribute
reference to a list:
cd examples/payment_dispute_agent
agent-eval benchmark test_suite.jsonl \
--agent mock_agent:run_dispute --registry mock_agent:build_registry \
--models models.json --sim-clock
agent-eval benchmark test_suite.jsonl \
--agent mock_agent:run_dispute --registry mock_agent:build_registry \
--models mock_agent:MODELS --sim-clock --max-concurrency 4
agent-eval scan "card 4111 1111 1111 1111, CVV 123"
OpenTelemetry mapping
Each evaluated run becomes one trace. Payloads (prompts, tool arguments, completions) are never exported. Only names, timings, token counts, verdicts and masked evidence leave the process.
| Source | OTel span name | Attributes |
|---|---|---|
| Session | invoke_agent {session name} (root) |
gen_ai.operation.name=invoke_agent, gen_ai.agent.name, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens (deduplicated totals), agent_eval.trace_id |
| Agent span | invoke_agent {agent} |
gen_ai.operation.name=invoke_agent, gen_ai.agent.name, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens |
| Tool span | execute_tool {tool} |
gen_ai.operation.name=execute_tool, gen_ai.tool.name, gen_ai.agent.name |
| Model span | chat {model} |
gen_ai.operation.name=chat, gen_ai.request.model, token usage |
| Failed span | status ERROR |
error.type |
| Every child span | agent_eval.span_id, and agent_eval.violations when an invariant failed on it |
Id correlation. The exported OTel trace id and span ids are the trajectory's own ids
(when they are valid hex, which the generated ones are). So the ids in
agent_eval.span_ids on a failed result are real span ids in Splunk, Dynatrace or Jaeger.
Custom non hex ids fall back to random OTel ids and stay findable through agent_eval.span_id.
Verdicts and metrics sit on the root span:
| Item | Where | Attributes |
|---|---|---|
| Run verdict | root attributes | agent_eval.verdict (pass or block), agent_eval.blocked_at, agent_eval.violations, agent_eval.violation_count |
| Trajectory metrics | root attributes | agent_eval.trajectory.latency_ms, .hops, .span_count, .tool_calls, .tool_errors, .total_tokens |
| One invariant result | root event gen_ai.evaluation.result |
gen_ai.evaluation.name, gen_ai.evaluation.score.value (1.0 or 0.0), gen_ai.evaluation.score.label (pass or fail), gen_ai.evaluation.explanation, agent_eval.severity, agent_eval.stage, agent_eval.evidence, agent_eval.metric.* |
The agent_eval.* names are project specific because no convention covers them. The GenAI
conventions are still marked as in development upstream, so all names live as constants at the
top of telemetry/otel_exporter.py. Check them against the semantic conventions version your
backend expects.
Exporters
from agent_eval.telemetry import JsonFileSpanExporter, TelemetryEmitter, make_otlp_exporter
with TelemetryEmitter(
exporters=[JsonFileSpanExporter("out/otel_spans.jsonl")], # synchronous
batch_exporters=[make_otlp_exporter()], # background batches
service_name="payment-dispute-agent",
) as emitter:
session = EvaluationSession("dispute", invariants=registry, emitter=emitter)
make_otlp_exporter() is the standard OTLP over HTTP exporter and reads the standard
environment variables. Any OTLP endpoint works, including an OpenTelemetry Collector in front
of Splunk or Dynatrace:
export OTEL_EXPORTER_OTLP_ENDPOINT="http://otel-collector:4318"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Api-Token <token>"
For direct ingestion, take the OTLP traces URL and auth header from your vendor's
documentation (Dynatrace uses an Api-Token authorization header, Splunk Observability Cloud
uses an X-SF-Token header). The emitter owns a private TracerProvider and does not touch
the global one.
Example: payment dispute agent
examples/payment_dispute_agent simulates Triage, Ledger Lookup and Resolution agents. No
model is called. Failure modes are injected per model tier from the dataset, which makes every
run reproducible.
| Case | Expectation | What it exercises |
|---|---|---|
nominal-refund, nominal-status |
pass | Clean runs |
adversarial-ssn-in-prompt |
block, no_pii |
Input gate |
adversarial-pan-cvv-in-prompt |
block, pci_compliant |
Input gate, Luhn |
hallucinated-refund-amount |
pass | Weak tier invents an amount |
routing-loop |
pass | Weak tier ping pongs between agents |
swallowed-ledger-timeout |
pass | Strong tier retries, weaker tiers answer anyway |
pii-echo-in-answer |
pass | Weak tier leaks an email in the answer |
context-bloat-handoffs |
pass | Weak tier forwards the whole transcript |
degraded-ledger-sla |
block, sla_bounds |
Latency budget hard fail |
run_eval.py shows the input gate, the output gate through @evaluate_agent, a mid run block
on a routing loop, the frontier table, and the span export to out/otel_spans.jsonl.
Limits
- Cooperative SLA. Budgets are checked at span boundaries. A call that is still running is not preempted. Put a transport timeout on the call itself.
- Recall is not perfect. Regex, checksum and entropy detection catches structured identifiers. It does not catch names, addresses or free text PII. Luhn has a one in ten false positive rate on random 16 digit numbers. A routing number with no keyword near it is missed by default. Treat these checks as a deterministic floor and not as a DLP product.
- Strict grounding. Exact match only. Rounded or derived amounts fail. A standalone number
in a tool string (
"id 1001") still grounds; useground_from_strings=Falseto rule that out. Currency is not compared. Spelled-out amounts ("forty two dollars") and numbers without a currency marker ("refund 42.50") are not extracted as money. European decimal commas (€12,50,1.234,56 EUR) are not parsed and block as unparseable figures. - Acknowledgement is a heuristic. "We couldn't deliver your parcel, refund approved" after
a ledger timeout reads as an acknowledgement. Use
allow_acknowledgement=Falsewhere that matters and mark handled failures withscope.mark_handled(). - Tool payload scope. PII and PCI checks scan tool payloads by default. If a tool
legitimately returns customer PII, narrow the scope:
assert_no_pii(scopes={"input", "output"}). - Token roll up is inferred. A parent whose input and output usage are both at least the sum of its children is read as a roll up. A parent with real usage of its own that happens to exceed its children is under counted by the children's share. Record model calls as child spans, or put usage on the parent, but do not mix the two under one parent.
- Passthrough streaming is not fail closed. See the streaming table.
- Threads. Context local span parents cover asyncio. Plain threads need
parent_id. - Cost of checks. Payload scanning is linear in the run: each payload is scanned when it is recorded and once more in the final pass. Structural checks (DAG, routing, tokens) still walk the span list at every span boundary. That is about 1 to 2 ms per boundary at 1,600 spans on a laptop class CPU.
- Simulated benchmark numbers. The bundled example uses fictional models, prices and latencies. Plug in a real runner for real numbers.
Repository layout
agent-invariant-eval/
├── pyproject.toml
├── README.md
├── CHANGELOG.md
├── src/agent_eval/
│ ├── schemas.py Span, Trajectory, AssertionResult, EvalReport
│ ├── decorators.py @evaluate_agent, EvaluationSession, SimClock
│ ├── cli.py agent-eval scan / benchmark
│ ├── invariants/
│ │ ├── base.py BaseInvariant, fail-closed InvariantRegistry
│ │ ├── compliance.py PII, Luhn PCI, numeric grounding
│ │ └── topology.py DAG, loops, hop limits, context bloat, tool failures, SLA
│ ├── telemetry/
│ │ └── otel_exporter.py GenAI span mapping, JSON Lines and OTLP exporters
│ └── benchmark/
│ └── frontier.py Replay runner, p95, Pareto frontier, recommendation
├── examples/payment_dispute_agent/
│ ├── mock_agent.py
│ ├── models.json
│ ├── test_suite.jsonl
│ └── run_eval.py
└── tests/
├── test_compliance.py
├── test_topology.py
├── test_frontier.py
└── test_runtime.py
Disclaimer
This is a personal open-source project and is not affiliated with, sponsored by, or endorsed by any current or past employer. All example datasets, model names, latencies, and prices are fictional.
Metadata
Release files for agent-invariant-eval 0.3.1
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| agent_invariant_eval-0.3.1.tar.gz | 79.3 kB | With provenance | Details for agent_invariant_eval-0.3.1.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| agent_invariant_eval-0.3.1-py3-none-any.whl | Python 3 | none | any | Details for agent_invariant_eval-0.3.1-py3-none-any.whl |
Total release size: 133.0 kB
Release files / agent_invariant_eval-0.3.1.tar.gz
| Download URL | agent_invariant_eval-0.3.1.tar.gz |
|---|---|
| Size | 79.3 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
9cb6826b37c0a3f3f18ec3ddc5ea2bc96ae92c901198f9c4133c74ca35cebf56
|
|
BLAKE2b-256 checksum How to use checksums |
f20ab718ccd4311e2e3f9cfa71dbdda14424f49d6b531f424297d6d5a81efbdd
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logRelease files / agent_invariant_eval-0.3.1-py3-none-any.whl
| Download URL | agent_invariant_eval-0.3.1-py3-none-any.whl |
|---|---|
| Size | 53.7 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
9d73c191d5203b641cff6e7a9d5d84afea4b85c95e3939e58e066a3a9f2e3f33
|
|
BLAKE2b-256 checksum How to use checksums |
7e8f1199621a26f7f948cce3690db2e563cbd7632f0b949c00578105f8b26ef1
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logSecurity for agent-invariant-eval 0.3.1
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for agent_invariant_eval-0.3.1.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.