Audit and Federation for AI agents. A small, transport-independent message layer for the questions A2A, MCP and plain JSON-RPC do not answer:
- Audit — signed causal events with cone commitments, so "these are all the events" is checkable instead of asserted.
- Evidence — Merkle-bound blobs, salted commitments, selective disclosure with inclusion proofs.
- Rebuttable claims — a decision can be justified, challenged, rebutted and adjudicated inside the same log.
- Attestation — an auditor's verdict is itself an event, so audits can be audited.
- Federation — signed domain descriptors, rotation pre-commitment, revocation, gateway proofs, loop-free routing.
Antares is not a transport. It defines no handshake, session, streams, frame header, or retransmission. Carry messages over HTTP/3, A2A, MCP, TCP+TLS, or WebSockets.
Two questions matter when agents cross organizations:
- What exactly decided this, and can I tell it was not edited? A signed event names its actor, its key, its algorithm, its parents and the cone of history those parents commit to. A verifier recomputes the cone root; a truncated history becomes visible instead of plausible.
- Who do I talk to, and is that identity real? A signed descriptor lists gateways and trust anchors; rotation requires the outgoing key to pre-commit to the successor, and revocation is signed inside the descriptor.
Telemetry can be sampled and dropped. Evidence cannot. Antares is built for the second category: the output is something a third party can verify offline, without trusting your logs or your infrastructure.
pip install antaresRuntime dependencies: cbor2, cryptography. The antares-verify console
script is installed with the package.
from antares import AuditLog, AuditEvent, generate_keypair, verify_cone
private_key, public_key = generate_keypair()
log = AuditLog(signing_key=private_key, context_id=b"conversation-1",
key_id="urn:antares:key:planner")
event = AuditEvent(
event_id="urn:example:event:1",
actor_node_id="urn:example:node:planner",
actor_domain_id="urn:example:domain:us",
event_type="order.approve",
rule_id="policy.ap",
rule_version="1.2",
observed_at="2026-10-19T10:00:00Z",
logical_clock=1,
)
log.add(event)
assert log.verify_signature(event, public_key)
report = verify_cone([e.to_wire() for e in log.list_events()])
assert report["ok"] and report["complete"]What add enforces:
- no self-parent, no causal cycle (
CAUSAL_CYCLE); - at most 8 direct parents (
TOO_MANY_PARENTS); - missing parents are signed into
ur, not silently dropped; cr/cscommit to the parent cone, so later truncation is detectable.
from antares import Warrant, CounterEvidence, WarrantLedger
warrant = Warrant(
warrant_id="w1",
target_cone_root=event.cone_root,
target_size=event.cone_size + 1,
decision_event_id=event.event_id,
necessity="necessary",
rule_id="policy.ap",
asserted_at="2026-10-19T10:00:01Z",
).sign(private_key, "urn:antares:key:planner")
ledger = WarrantLedger()
ledger.add_warrant(warrant)
assert ledger.state_of("w1") == "ASSERTED"
counter = CounterEvidence(
counter_id="c1", warrant_id="w1",
counter_cone_root="sha256:" + "11" * 32,
slot="alternatives", kind="evidence",
expected="cmt:" + "22" * 32, actual="cmt:" + "33" * 32,
).sign(private_key, "urn:antares:key:planner")
ledger.add_counter(counter)
assert ledger.state_of("w1") == "CHALLENGED"from antares import EvidenceSet, build_bundle, verify_bundle, write_bundle
evidence = EvidenceSet()
evidence.add(b"invoice-42")
evidence.add(b"chat-log")
data = build_bundle(
events=log.wire_list(),
evidence=evidence,
disclosures=[evidence.disclose([0])], # share one chunk, prove the set
)
write_bundle("case-42.ant", data)
keys = {"urn:antares:key:planner": public_key}
report = verify_bundle(data, keys)
assert report["ok"]antares-verify case-42.ant --key urn:antares:key:planner=<hex-pubkey>The bundle carries events, checkpoints, attestations, evidence, disclosure proofs and timestamp tokens; the manifest hash is checked first, then every signature, then the causal cone.
import time
from antares import (
FederationRegistry, DomainDescriptor, Gateway, TrustAnchor,
sign_descriptor, generate_keypair, key_fingerprint,
)
domain_priv, domain_pub = generate_keypair()
domain = "urn:antares:domain:remote"
registry = FederationRegistry("urn:antares:domain:local")
registry.add_trust_anchor(domain, domain_pub,
next_key_hash=key_fingerprint(domain_pub))
now = time.time()
descriptor = DomainDescriptor(
domain_id=domain, descriptor_version=1,
valid_from=now - 60, valid_until=now + 3600,
gateways=[Gateway("http3://gw.example:443", "http3", 10)],
trust_anchors=[TrustAnchor("urn:antares:key:remote", "ed25519",
domain_pub)],
)
sign_descriptor(descriptor, domain_priv)
registry.register(descriptor)src/antares/
types.py # version, error codes, bounds, algorithms
cbor_utils.py # canonical CBOR
signing.py # ed25519 + hybrid provider, signature encoding
envelope.py # the signed envelope shared by all families
merkle.py # RFC 6962 shape, inclusion proofs
audit.py # AuditEvent, AuditLog, cone verification
checkpoint.py # checkpoints, cross-anchors, split-view detection
disclosure.py # salted commitments, evidence sets, proofs
warrant.py # warrants, counter-evidence, derived states
attestation.py # verdicts with operator-set hashes
bundle.py # .ant evidence bundles
federation.py # descriptors, rotation, revocation, routing
cli.py # antares-verify
vectors.py # deterministic conformance vectors
schemas/ # JSON Schemas
tests/ # conformance suite + vectors
ANTARES_SPEC.md # the specification (v2.1)
CONFORMANCE.md # requirement list (C/E/A/K/P/D/W/T/B/F/V)
| Standard | Layer | Relationship |
|---|---|---|
| HTTP/3 (QUIC) | Transport | Carries Antares messages. |
| MCP | Tool/resource protocol | Antares adds signed events and identity. |
| A2A | Agent RPC | Antares is the audit/federation layer beneath the call. |
| TLS 1.3 | Channel security | Authenticates the connection; Antares signs the content. |
| SCITT / Sigstore / in-toto | Transparency and attestation | Compatible evidence model. Antares adds causal-cone completeness, rebuttable claims and selective disclosure; an entry-level transparency log remains a valid backend. |
2.1 is not wire-compatible with 2.0: the envelope signs key_id and
algorithm, moves ctx into every message, and replaces the 2.0 payload
digest with the evidence root. A 2.1 verifier rejects v: "2.0" rather than
reinterpreting it.
See CONFORMANCE.md, tests/vectors/v2.1.json, and:
PYTHONPATH=src python -m unittest discover -s tests -vCHANGELOG_v2.1.md— evidence closure, rebuttal, disclosure, retention.CHANGELOG_v2.0.md— redefinition as audit and federation layer.
- Code: Apache License 2.0.
- Specification: CC BY 4.0.