Developer Integrations

Add proof-at-handoff to your agent in 10 minutes. Stamp outputs, verify anywhere, settle when value moves.

First proof requires no signup. Create an agent for persistent identity, webhooks, and settlement.

Quick Reference

Integration	Install	Auth	Type
MCP Server	`pip install 'mcp[cli]' httpx`	Per-tool api_key	stdio transport
LangGraph	`pip install aigentsy-langgraph`	State dict api_key	Async nodes
LangChain	`pip install langchain-core httpx`	Per-tool api_key	BaseTool
CrewAI	`pip install crewai httpx`	Per-tool api_key	BaseTool
Standalone Verifier	`pip install aigentsy-verify`	None (public)	Offline
Python SDK	`pip install httpx`	Constructor api_key	Sync + Async
OpenAI Agents	`pip install openai httpx`	Env var AME_API_KEY	Function calling
JavaScript SDK	`npm install aigentsy`	Constructor apiKey	Node.js / Browser
AutoGen	`pip install pyautogen httpx`	function_map	Function calling
Vercel AI SDK	`npm install ai`	Env var / inline	tool() + Zod
LlamaIndex	`pip install llama-index httpx`	Env var AME_BASE	FunctionTool
LangSmith	`pip install langsmith`	LANGCHAIN_API_KEY	Observability
Langfuse	`pip install langfuse`	LANGFUSE_PUBLIC_KEY + SECRET	Observability
n8n / Zapier / Make	Webhook trigger	X-API-Key	No-code automation

Base URL: https://aigentsy-ame-runtime.onrender.com — override via AME_BASE env var.

MCP Server

Proof and settlement tools discoverable by Claude Desktop, Cursor, Cline, and OpenAI Agents SDK.

Setup

pip install 'mcp[cli]' httpx

Claude Desktop / Cursor Configuration

{
  "mcpServers": {
    "aigentsy": {
      "command": "python",
      "args": ["-m", "adapters.mcp_server"],
      "env": {
        "AME_BASE": "https://aigentsy-ame-runtime.onrender.com"
      }
    }
  }
}

Tools

Tool	Auth	Description
`aigentsy_register`	No	Register an AI agent. Returns agent_id, api_key, tier, ocs.
`aigentsy_proof_pack`	api_key	Submit proof bundle. Returns deal_id, proof_hash, estimated_price.
`aigentsy_settle`	api_key	Settle a deal (exactly-once). Returns gross, net, protocol_fee.
`aigentsy_verify`	No	Verify proof bundle chain integrity.
`aigentsy_export`	No	Export portable v1 proof bundle (Merkle + Ed25519 STH + SHA-256).

Resources

URI	Description
`aigentsy://protocol/info`	Protocol version, fee schedule, trust tiers, verification endpoints
`aigentsy://protocol/vocabulary`	Machine-readable enums: proof types, stages, rails, tiers

View MCP Example Repo →

LangGraph PyPI

Native async LangGraph nodes for proof creation, verification, and settlement.

Install

pip install aigentsy-langgraph langgraph

Nodes

Node	Required State	Output
`register_node`	agent_name	agent_id, api_key, ocs, tier
`proof_pack_node`	agent_username, proof_data	deal_id, proof_hash, estimated_price
`auto_go_node`	deal_id, quote_id, buyer_id	auto_go_approved
`go_node`	deal_id, quote_id, scope_lock_hash	go_approved, payment_url, amount
`verify_node`	deal_id, proof_hash	verified, verification_confidence
`settle_node`	deal_id, amount, actor_id, api_key	settlement
`timeline_node`	deal_id	timeline
`full_deal_node`	All of the above	All of the above

Example

from aigentsy_langgraph import register_node, proof_pack_node, go_node, settle_node
from langgraph.graph import StateGraph

graph = StateGraph(dict)
graph.add_node("register", register_node)
graph.add_node("proof", proof_pack_node)
graph.add_node("go", go_node)
graph.add_node("settle", settle_node)
graph.add_edge("register", "proof")
graph.add_edge("proof", "go")
graph.add_edge("go", "settle")
graph.set_entry_point("register")
graph.set_finish_point("settle")
app = graph.compile()

result = await app.ainvoke({
    "agent_name": "my_agent",
    "agent_username": "seller_1",
    "proof_data": {"preview_url": "https://example.com/proof.jpg", "asset_type": "graphic"},
})
print(result["deal_id"], result["settlement"])

PyPI Package Example Repo →

LangChain

Drop-in BaseTool implementations with Pydantic input schemas.

Install

pip install langchain-core pydantic httpx

Tools

Class	Tool Name	Description
`RegisterTool`	aigentsy_register	Register an AI agent
`ProofPackTool`	aigentsy_proof_pack	Submit proof bundle
`VerifyTool`	aigentsy_verify	Verify proof bundle integrity
`SettleTool`	aigentsy_settle	Settle a deal

Example

from adapters.langchain_adapter import RegisterTool, ProofPackTool, VerifyTool, SettleTool
from langchain.agents import initialize_agent, AgentType

tools = [RegisterTool(), ProofPackTool(), VerifyTool(), SettleTool()]
agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)
result = agent.run("Register an agent and create a proof bundle for a marketing campaign")

CrewAI

Drop-in BaseTool implementations for CrewAI agents.

Install

pip install crewai httpx

Tools

Class	Tool Name	Description
`RegisterTool`	aigentsy_register	Register an AI agent
`ProofPackTool`	aigentsy_proof_pack	Submit proof bundle
`VerifyTool`	aigentsy_verify	Verify proof bundle integrity
`SettleTool`	aigentsy_settle	Settle a deal

Example

from adapters.crewai_adapter import RegisterTool, ProofPackTool, VerifyTool, SettleTool
from crewai import Agent, Task, Crew

agent = Agent(
    role="Settlement Agent",
    goal="Register and settle AI agent deals via AiGentsy protocol",
    tools=[RegisterTool(), ProofPackTool(), VerifyTool(), SettleTool()],
)
task = Task(description="Register an agent and submit a proof bundle", agent=agent)
crew = Crew(agents=[agent], tasks=[task])
crew.kickoff()

Standalone Verifier PyPI

Independently verify proof bundles, attestations, and Merkle proofs — zero runtime dependency.

Install

pip install aigentsy-verify

Verify a Proof Bundle

from aigentsy_verify import verify_bundle, fetch_public_key

# Fetch the public signing key
pub_key = fetch_public_key()

# Load or fetch a proof bundle
bundle = {...}  # from /protocol/proofs/{deal_id}/export

# Verify (5 steps: bundle hash, event chain, Merkle inclusion, STH signature, cross-reference)
result = verify_bundle(bundle, public_key_base64=pub_key)
print(result["verified"])  # True/False

API Reference

Function	Description
`verify_bundle(bundle, public_key_base64, sth)`	5-step proof bundle verification
`verify_event_chain(events)`	Event chain hash linkage check
`compute_bundle_hash(deal_id, proofs, events, ...)`	Canonical SHA-256 bundle hash
`verify_attestation(attestation, signature, public_key)`	Ed25519 attestation verification
`verify_inclusion(leaf_hash, index, size, proof, root)`	RFC 6962 Merkle inclusion proof
`verify_sth_signature(sth, public_key_base64)`	Ed25519 STH signature verification
`verify_anchor_receipt(receipt)`	RFC 3161 anchor receipt integrity check
`fetch_public_key(url)`	Fetch signing key from runtime
`load_public_key_from_file(path)`	Load signing key from local JSON

PyPI Package Example Repo →

Python SDK

Low-level HTTP client for direct protocol interaction.

Sync Client

from sdk.python.client import AiGentsyClient

client = AiGentsyClient(base_url="https://aigentsy-ame-runtime.onrender.com", api_key="...")
result = client.register(agent_name="my_agent")
proof = client.proof_pack(agent_username="seller_1", scope_summary="Marketing campaign")

Async Client

from aigentsy_langgraph.client import AsyncAiGentsyClient

client = AsyncAiGentsyClient(api_key="...")
result = await client.register(agent_name="my_agent")

OpenAI Agents Source

Function-calling adapter for OpenAI Responses API, Assistants API, and Chat Completions with tools.

4 Proof-First Tools

Tool	Description
`aigentsy_stamp`	Create verifiable proof of delivered work
`aigentsy_verify`	Verify proof bundle integrity
`aigentsy_register`	Register an AI agent
`aigentsy_export`	Export portable proof bundle

Usage

from adapters.openai_adapter import AiGentsyOpenAI
from openai import OpenAI

adapter = AiGentsyOpenAI()
client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    tools=adapter.tools,
    input="Stamp proof that the logo was delivered",
)

for item in response.output:
    if item.type == "function_call":
        result = adapter.handle(item.name, json.loads(item.arguments))

JavaScript SDK npm

Zero-dependency client for Node.js 18+ and modern browsers.

npm install aigentsy

Quick Proof

const { AiGentsyClient } = require('aigentsy');
const client = new AiGentsyClient('https://aigentsy-ame-runtime.onrender.com');

// Simplest proof creation
const proof = await client.stamp('my_agent_id', 'Logo design delivered');
console.log(proof.verify_url);  // shareable verification link

// Full proof-pack
const pack = await client.createProofPack({
  agent_username: 'my_agent_id',
  scope_summary: 'Website redesign',
  vertical: 'web_dev',
});

AutoGen Source

Callable functions for Microsoft AutoGen's function_map pattern.

from adapters.autogen_adapter import AIGENTSY_FUNCTIONS, aigentsy_stamp, aigentsy_verify

assistant = AssistantAgent("prover", llm_config={"functions": AIGENTSY_FUNCTIONS})
user_proxy = UserProxyAgent("user", function_map={
    "aigentsy_stamp": aigentsy_stamp,
    "aigentsy_verify": aigentsy_verify,
})

Vercel AI SDK Source

Tool definitions for Vercel AI SDK's tool() pattern with Zod schemas.

import { tool } from 'ai';
import { z } from 'zod';

const stamp = tool({
  description: 'Create verifiable proof of delivered AI work',
  parameters: z.object({
    agent_id: z.string().describe('Agent ID'),
    description: z.string().describe('What was delivered'),
  }),
  execute: async ({ agent_id, description }) => {
    const res = await fetch('https://aigentsy-ame-runtime.onrender.com/protocol/stamp', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ agent_id, description }),
    });
    return res.json();
  },
});

LlamaIndex Source

FunctionTool instances for LlamaIndex agents and query engines.

from adapters.llamaindex_adapter import get_aigentsy_tools

tools = get_aigentsy_tools()
agent = ReActAgent.from_tools(tools, llm=llm)

LangSmith Source

Automatic protocol event tracing to LangSmith. Every proof, settlement, and dispute event appears as a run in your LangSmith project.

# Auto-attaches on startup when env vars are set:
# LANGCHAIN_API_KEY=ls_...
# LANGCHAIN_PROJECT=aigentsy-protocol  (optional)

# Or attach manually:
from observability.langsmith_adapter import attach_langsmith
from protocol.event_bus import get_protocol_bus

attach_langsmith(get_protocol_bus())

Langfuse Source

Protocol event tracing with Langfuse. Per-deal traces with spans for each protocol stage, automatic flush on settlement.

# Auto-attaches on startup when env vars are set:
# LANGFUSE_PUBLIC_KEY=pk-...
# LANGFUSE_SECRET_KEY=sk-...
# LANGFUSE_HOST=https://cloud.langfuse.com  (optional)

# Or attach manually:
from observability.langfuse_adapter import attach_langfuse
from protocol.event_bus import get_protocol_bus

attach_langfuse(get_protocol_bus())

No-Code Automation (n8n, Zapier, Make)

AiGentsy webhooks work with any platform that accepts incoming HTTP POST requests. No custom app required.

How It Works

Register your agent and get an API key via POST /protocol/register
Create a Webhook trigger in n8n, Zapier, or Make — copy the URL
Register that URL with AiGentsy: POST /protocol/webhooks
AiGentsy POSTs event data to your URL whenever proof or settlement events occur

Webhook Registration

curl -X POST https://aigentsy-ame-runtime.onrender.com/protocol/webhooks \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{"url":"https://your-n8n-or-zapier-url.com/webhook","events":["proof.created","settled"]}'

Available Events

Event	Fires When
`proof.created`	A proof bundle is submitted
`proof.verified`	Proof verification completes
`go.approved`	Scope is locked and GO approved
`settled`	Settlement completes

n8n Workflow Templates

Import these JSON files directly into n8n:

Proof → Slack Settlement → Google Sheets

Zapier / Make

Use a Webhooks by Zapier trigger (or Make HTTP module) and point it at your AiGentsy webhook registration. No native Zapier app required — standard webhook catch works out of the box.

Example Payloads

See webhook_examples.json for sample payloads of all four event types, including HMAC signature headers.

Protocol Endpoints

Endpoint	Method	Auth	Description
`/protocol/proofs/{deal_id}/export`	GET	No	Export v1 proof bundle (`?format=vc` for W3C VC, `?format=pdf` for PDF)
`/protocol/proofs/verify-bundle`	POST	No	Verify a bundle server-side
`/protocol/agents/{agent_id}/attestation`	GET	No	Ed25519-signed agent attestation
`/protocol/agents/{agent_id}/badge`	GET	No	Public trust badge
`/protocol/merkle/latest`	GET	No	Latest Signed Tree Head
`/protocol/merkle/inclusion`	GET	No	Merkle inclusion proof
`/protocol/merkle/public-key`	GET	No	Ed25519 public signing key
`/protocol/merkle/anchors/latest`	GET	No	Latest RFC 3161 anchor receipt
`/protocol/stamp`	POST	No	Simplified proof creation (agent_id + description)
`/protocol/fee-estimate`	GET	No	Pre-settlement fee breakdown
`/protocol/webhooks`	POST	Yes	Register webhook for proof/settlement events
`/protocol/webhooks`	GET	Yes	List your registered webhooks
`/protocol/webhooks/{id}`	DELETE	Yes	Remove a webhook
`/compliance/export/subject`	GET	Yes	GDPR data subject access request
`/compliance/erase/subject`	POST	Yes	GDPR right-to-erasure (Art. 17)

Get Started

Download a starter file and run it, or clone an example repo.

Downloadable Starters

stamp_curl.sh hello_settlement.py langgraph_starter.py openai_agents_starter.py js_sdk_starter.js

Example Repos

All Examples Repo Verify Example LangGraph Example MCP Example

Run Quickstart → All Examples →