VibeTensor/attestix

AI agent identity, signed credentials, delegated authority and portable governance evidence. Python core and offline verifier SDKs.

Attestix – Signed identity & evidence for AI agents

What it is – Attestix is an open‑source toolkit that lets you create, sign, store and verify cryptographically‑verifiable identities and evidence for AI agents. It bundles a Python library, a CLI, a FastAPI‑based REST server and a Streamlit dashboard, plus language‑specific verifier packages (JS/TS, Go, Rust, Java, R). The goal is to give developers a concrete way to record the documentation required by AI‑governance regimes (e.g., the EU AI Act) and to prove that evidence to auditors or other systems.

Core capabilities

Area What Attestix provides
Identity Unified Agent Identity Tokens (UAITs) that combine OAuth, DID (did:key, did:web), API‑key and custom formats. Local erasure tools are included.
Verifiable credentials Full W3C Verifiable Credential (VC) issuance with Ed25519Signature2020 proofs, plus Verifiable Presentations (VP) for challenge‑response verification.
Delegation UCAN‑style capability tokens (EDDSA‑signed JWTs) for fine‑grained delegation between agents.
Compliance Pre‑built EU AI Act risk‑profile templates, gap analysis, and auto‑generation of Annex V declarations wrapped in VCs.
Provenance Recording of training‑data sources (Article 10), model lineage (Article 11) and hash‑chained audit trails (Article 12).
Reputation Recency‑weighted trust scores (0 → 1) with per‑category breakdowns.
Blockchain anchoring Optional anchoring of artifact hashes to Base L2 via the Ethereum Attestation Service (EAS) using Merkle batching.
Interoperability Language‑agnostic verification libraries and a canonical‑JSON + Ed25519 profile; conformance fixtures are published for each language.

Installation (Python – the reference implementation)

# Pin the latest reviewed release
pip install attestix==0.4.2

Optional extras:

  • pip install 'attestix[api]' – pulls in FastAPI/uvicorn for the REST server.
  • pip install streamlit – enables the web dashboard.

Other languages install the matching package (e.g., npm install attestix@0.4.2, go get github.com/VibeTensor/attestix-go@v0.4.2).

Quick start (Python library)

from attestix.services.identity_service import IdentityService
from attestix.services.compliance_service import ComplianceService
from attestix.services.credential_service import CredentialService

# 1️⃣ Create an agent identity (UAIT + DID)
identity_svc = IdentityService()
agent = identity_svc.create_identity(
    display_name="MyAgent",
    source_protocol="manual",
    capabilities=["data_analysis", "reporting"],
    description="Analyzes quarterly financial data",
    issuer_name="VibeTensor",
    expiry_days=365,
)
agent_id = agent["agent_id"]

# 2️⃣ Record a compliance profile (EU AI Act risk categorisation)
compliance_svc = ComplianceService()
profile = compliance_svc.create_compliance_profile(
    agent_id=agent_id,
    risk_category="limited",
    provider_name="VibeTensor",
    intended_purpose="Analyzes quarterly financial data",
)

# 3️⃣ Issue a verifiable credential for the agent
credential_svc = CredentialService()
vc = credential_svc.issue_credential(
    subject_id=agent_id,
    credential_type="AgentIdentityCredential",
    issuer_name="VibeTensor",
    claims={"capabilities": ["data_analysis", "reporting"]},
    expiry_days=365,
)
print(vc["proof"]["type"])   # → Ed25519Signature2020

Run the bundled demo to see the whole workflow:

python examples/quickstart.py

Using the CLI

attestix init --name MyBot                 # create a new agent identity
attestix compliance <agent-id>             # run a gap‑analysis against EU AI Act
attestix verify <agent-id>                 # cryptographically verify the identity
attestix audit <agent-id>                  # view the hash‑chained audit trail
attestix credential --list                 # list stored Verifiable Credentials

Running the REST server (for integration with LangChain, OpenAI Agents SDK, CrewAI, etc.)

export ATTESTIX_API_KEY=your-secret-key   # required by default
uvicorn attestix.api.main:app --reload    # Swagger UI at http://localhost:8000/docs

The API follows the same namespace (attestix.*) as the library, exposing endpoints for identity, credential issuance, delegation, compliance, provenance and blockchain anchoring.

Architecture at a glance

attestix/                     # Python package
 ├─ main.py                  # MCP server entry point
 ├─ cli.py                   # console script (attestix)
 ├─ api/                     # FastAPI surface
 │   └─ routers/ …
 ├─ auth/                    # Ed25519 key handling, SSRF protection
 ├─ services/                # Business‑logic modules (identity, did, credential, …)
 ├─ storage/                 # Pluggable back‑ends (file, memory, PostgreSQL)
 ├─ signing/                 # In‑process signer or external KMS
 ├─ audit/                   # Tamper‑evident event chain (SHA‑256)
 ├─ blockchain/              # Merkle tree + EAS anchoring helpers
 └─ tools/                   # MCP tool definitions (one file per module)

The pre‑0.4 flat layout is kept as deprecation shims that emit a warning and will be removed in v0.5.0.

When (and why) you’d use Attestix

  • AI‑governance pipelines – automatically generate the signed evidence required for EU AI Act compliance (risk profile, data provenance, model lineage, conformity declaration).
  • Multi‑agent ecosystems – give each autonomous component a verifiable DID‑based identity and delegate capabilities securely via UCAN tokens.
  • Auditable deployments – hash‑chain every action, anchor critical hashes on‑chain, and retrieve a tamper‑evident audit log for regulators or customers.
  • Cross‑language verification – verify the same credential in Python, JavaScript, Go, Rust, Java, or R using the published canonical‑JSON profile.

Caveats & security notes (as stated in the README)

  • The project is pre‑1.0; no third‑party security audit has been performed.
  • Replay protection is enforced only when the verifier supplies a fresh challenge; a raw signature alone is insufficient.
  • The default REST server is single‑tenant; the API key does not grant cross‑tenant access.
  • Local purge removes only locally stored records; external replicas, backups or on‑chain anchors must be handled separately.
  • legal_conformity fields are drafts; they do not constitute a legal assessment.

Documentation & community

Bottom line: Attestix gives developers a ready‑made, crypto‑backed stack for creating trustworthy AI‑agent identities, recording the evidence required by emerging regulations, and proving that evidence to other services or auditors— all from a single Python package with language‑agnostic verification support.

Related

  • Project
    verifywise-ai/verifywise

    VerifyWise is an open‑source AI‑governance platform that lets companies inventory models, evaluate LLMs, map risks to standards (EU AI Act, ISO 42001, NIST AI RMF, etc.), and generate audit‑ready reports. It runs a React front‑end, Node.js back‑end, PostgreSQL/Redis storage, and a Python EvalServer for LLM testing. Deployable on‑prem or in a private cloud via Docker/Kubernetes, it includes AI‑detection, policy management, Slack/Jira integrations, and an AI‑advisor chat.

  • Project
    iamfakeguru/agent-md

    agent‑md is a lightweight framework that installs rule files, git‑hooks, and helper scripts to turn AI coding assistants (Claude Code, Codex, Cursor, Windsurf) into contract‑driven agents. It provides a single source‑of‑truth markdown file (AGENT.md) plus enforceable checks (type‑check, lint, tests, visual screenshots, state updates) that block the model until the required evidence is present.

  • Project
    microsoft/agent-governance-toolkit

    Agent Governance Toolkit is a Microsoft‑maintained open‑source library that sits between autonomous AI agents and the tools they call, enforcing deterministic, auditable policies (allow/deny/require‑approval) written in YAML/OPA. It provides language‑specific SDKs (Python, TypeScript, .NET, Rust, Go), a CLI (`agt`) for compliance checks, and adapters for major agent frameworks, enabling production‑grade governance, attribution, and tamper‑evident logging.

  • Project
    trhhubsd/ARTEX

    ARTEX is an open‑source, LLM‑driven autonomous penetration‑testing platform. It combines a Go backend, embedded Next.js UI, and PostgreSQL to maintain a global asset graph and per‑task exploration graph. Agents (planner + workers) iteratively generate intents, run real security tools, record every step, and feed results back into the graphs. The system offers rich dashboards, asset sync from ScopeSentry, approval gating, self‑updating binaries, and multiple deployment options (Docker, one‑click script, cross‑platform releases). Licensed under AGPL‑3.0, it is intended for local learning and research only.

  • Dispatch
    AI × Crypto Roundup: Agent Payments, Decentralized Compute, and On‑Chain Marketplaces

    AI agents are moving from demo bots to on‑chain workers that can prove identity, get paid, and access decentralized compute and data marketplaces.