Get started with Ardyn.

from openai import OpenAI
import json
from ardyn_governance import govern_and_attest

client    = OpenAI(api_key="your-openai-key")
AGENT_ID  = "openai-agent-01"

def dispatch_tool(name, args):
    if name == "approve_invoice":
        return {"status": "approved", "invoice_id": args["invoice_id"]}
    raise ValueError(f"Unknown tool: {name}")

def run_governed_agent(messages, tools):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
    )
    message = response.choices[0].message
    for tool_call in (message.tool_calls or []):
        name = tool_call.function.name
        args = json.loads(tool_call.function.arguments)
        gov = govern_and_attest(name, args, result, AGENT_ID)
        if aea.get("decision") == "BLOCK":
            result = {"error": "blocked_by_ardyn", "reason": aea.get("reason")}
        else:
            result = dispatch_tool(name, args)
, AGENT_ID)
        print(f"Tool: {name} | Decision: {aea.get("decision")} | Result: {result}")
    return message

from openai import OpenAI
import json
from ardyn_governance import govern_and_attest

client = OpenAI(
    api_key="your-xai-key",
    base_url="https://api.x.ai/v1",
)
AGENT_ID = "xai-agent-01"

def run_governed_agent(messages, tools):
    response = client.chat.completions.create(
        model="grok-3",
        messages=messages,
        tools=tools,
    )
    message = response.choices[0].message
    for tool_call in (message.tool_calls or []):
        name = tool_call.function.name
        args = json.loads(tool_call.function.arguments)
        gov = govern_and_attest(name, args, result, AGENT_ID)
        if aea.get("decision") == "BLOCK":
            result = {"error": "blocked_by_ardyn", "reason": aea.get("reason")}
        else:
            result = dispatch_tool(name, args)
, AGENT_ID)
    return message

import anthropic
from ardyn_governance import govern_and_attest

client   = anthropic.Anthropic(api_key="your-anthropic-key")
AGENT_ID = "claude-agent-01"

def run_governed_agent(messages, tools):
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    tool_results = []
    for block in response.content:
        if block.type != "tool_use":
            continue
        name = block.name
        args = block.input
        gov = govern_and_attest(name, args, result, AGENT_ID)
        if aea.get("decision") == "BLOCK":
            result = {"error": "blocked_by_ardyn", "reason": aea.get("reason")}
        else:
            result = dispatch_tool(name, args)
, AGENT_ID)
        tool_results.append({
            "type": "tool_result",
            "tool_use_id": block.id,
            "content": str(result),
        })
    return tool_results

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool
from ardyn_governance import govern_and_attest
import functools

AGENT_ID = "langgraph-agent-01"

def ardyn_governed(fn):
    """Decorator: wrap any LangChain tool with Ardyn governance."""
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        tool_input = {"args": args, **kwargs}
        gov = govern_and_attest(fn.__name__, tool_input, result, AGENT_ID)
        if aea.get("decision") == "BLOCK":
            return f"Action blocked by governance: {aea.get('reason')}"
        result = fn(*args, **kwargs)
, AGENT_ID)
        return result
    return wrapper

@tool
@ardyn_governed
def approve_invoice(invoice_id: str, amount: float) -> dict:
    """Approve an invoice for payment."""
    return {"approved": True, "invoice_id": invoice_id, "amount": amount}

@tool
@ardyn_governed
def send_payment(vendor_id: str, amount: float) -> dict:
    """Send a payment to a vendor."""
    return {"sent": True, "vendor_id": vendor_id, "amount": amount}

tools     = [approve_invoice, send_payment]
tool_node = ToolNode(tools)

from crewai import Agent, Task, Crew
from crewai.tools import BaseTool
from ardyn_governance import govern_and_attest
from pydantic import BaseModel
from typing import Type

AGENT_ID = "crewai-agent-01"

class ArdynToolWrapper(BaseTool):
    """Base class: wraps any CrewAI tool with Ardyn governance."""
    ardyn_tool_fn: callable = None
    def _run(self, **kwargs) -> str:
        name      = self.name
        tool_input = kwargs
        gov = govern_and_attest(name, tool_input, result, AGENT_ID)
        if aea.get("decision") == "BLOCK":
            return f"Blocked: {aea.get('reason')}"
        result = self.ardyn_tool_fn(**kwargs)
, aea.get("trace_id"), AGENT_ID)
        return str(result)

class ApproveInvoiceTool(ArdynToolWrapper):
    name: str = "approve_invoice"
    description: str = "Approve an invoice for payment"
    ardyn_tool_fn: callable = lambda self, **kw: {"approved": True, **kw}

finance_agent = Agent(
    role="Finance Automation Agent",
    goal="Process invoices within policy",
    tools=[ApproveInvoiceTool()],
    verbose=True,
)

Node: HTTP Request (place AFTER your action node)
Method: POST
URL: https://api.ardyn.ai/v1/attest
Authentication: Header Auth
  Name: Authorization
  Value: Bearer {{ $env.ARDYN_API_KEY }}
Body (JSON):
{
  "api_key":    "{{ $env.ARDYN_API_KEY }}",
  "tool_name":  "{{ $node['Previous Node'].name }}",
  "input_hash": "{{ $node['Previous Node'].json | hash }}",
  "output_hash": "{{ $json | hash }}"
}
Then: IF node
  Condition: {{ $json.decision }} equals "BLOCK"
  True branch:  Stop workflow — governance rejected this action
  False branch: Continue (AEA minted)

// Ardyn attestation — place AFTER your action node (governance + AEA in one call)
const ARDYN_KEY = $env.ARDYN_API_KEY;
const toolName  = "send_payment";
const prevNode  = $input.first().json;
const response  = await $http.post({
  url: "https://api.ardyn.ai/v1/attest",
  headers: { "Authorization": `Bearer ${ARDYN_KEY}` },
  body: {
    api_key:     ARDYN_KEY,
    tool_name:   toolName,
    input_hash:  sha256(JSON.stringify(prevNode)),
    output_hash: sha256(JSON.stringify(prevNode)),
  },
});
if (response.decision === "BLOCK") {
  throw new Error(`Ardyn BLOCKED this action: ${response.reason}`);
}
return [{ json: { ...prevNode, ddc_id: response.ddc_id } }];

// Attestation node — place after your action node
const ddcId = $input.first().json.ardyn_ddc_id;
const result  = $input.first().json;
await $http.post({
  url: "https://api.ardyn.ai/v1/attest",
  headers: { "Authorization": `Bearer ${$env.ARDYN_API_KEY}` },
  body: {
    api_key:     $env.ARDYN_API_KEY,
    tool_name:   "send_payment",
    input_hash:  btoa(JSON.stringify($input.first().json)),
    output_hash: btoa(JSON.stringify(result)),
    metadata:    { trace_id: ddcId, agent_id: "n8n-workflow" },
  },
});
return [{ json: result }];

git clone https://github.com/Kylewilson04/ardyn.git
cd ardyn
cargo build --release -p ardyn-mcp-proxy
# Binary: ./target/release/ardyn-mcp-proxy

upstream_command     = ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/your/path"]
gateway_url          = "https://api.ardyn.ai"
api_key              = "ardyn_live_..."
tenant_id            = "your-tenant-id"
axiom_governance_url = "https://api.ardyn.ai"
axiom_api_key        = "ardyn_live_..."
inject_metadata      = true
log_level            = "info"

{
  "mcpServers": {
    "filesystem-governed": {
      "command": "/path/to/ardyn/target/release/ardyn-mcp-proxy",
      "args": ["--config", "/Users/you/.ardyn/proxy-filesystem.toml"]
    }
  }
}