The Integrator Is Increasingly an Agent

The pattern is familiar to anyone shipping developer tools in 2026: a human states the goal — "add decision tracing to our claims agent" — and a coding agent does the discovery, reads the reference, and writes the integration. The human reviews a diff. Which means your real onboarding funnel has a new first step: can a machine find out what you are and what it may do, without a human clicking through your site?

For a decision-tracing platform the stakes double, because the runtime consumer is an agent too — the thing creating traces, sealing decisions and retrieving precedent is the customer's agent, not the customer. Both halves of the lifecycle need machine-native surfaces. (The conceptual grounding — what tracing captures and why — lives in What Is Decision Tracing?.)

Discovery: the Signed Agent Card

Agent-to-agent discovery has a standard answer: a card at a well-known URL. AIAgentree publishes a signed agent card at /.well-known/agent-card.json — the standard path current conforming clients check — describing what the service is, which protocols it speaks, and where its endpoints live. Signed, so a client can verify who it is talking to before sending anything.

The card is public and unauthenticated by design: discovery has to work before credentials exist. It sits alongside the other machine-discovery surfaces — the public key set at /.well-known/jwks.json that third parties use to verify signed packets offline, and the MCP tool descriptions an agent framework reads at connection time.

The Ten Lines

Integration is deliberately small. With the Python SDK (pip install ai-agentree-sdk) or the TypeScript SDK (npm install @ai-agentree/sdk), wrapping one decision point looks like this:

from aiagentree import AgentreeClient

client = AgentreeClient(api_key="ask_...", base_url="https://api.aiagentree.com", tenant_id="acme")

# Trace your agent's decision point
trace = client.start_trace(
    agent_id="claims-agent",
    workflow_id="claim_approval",
    entity_type="claim",
    entity_id="7031",
)
trace.add_input("claim_amount", 1200, source="claims_db")
trace.add_step("s1", title="Policy active, premiums current", category="evidence", confidence=0.95)
trace.add_step("s2", title="Amount below auto-approve threshold", category="policy", confidence=0.9)
trace.seal("d1", action="approved", confidence=0.92)

A Free Tier a Machine Can Read (and Sign Up For)

Human-oriented pricing pages answer "what does it cost?". An agent evaluating integration needs a different artifact: which scopes exist, which are open, and where the boundaries are — machine-readable, so the evaluation can happen programmatically. AIAgentree's free tier is defined that way, and it covers the parts an agent needs to prove value end to end:

MCP and A2A: Meeting Agents Where They Run

Not every agent should carry an SDK. Two protocol surfaces cover the rest:

"Ten Lines Can't Possibly Be Enough"

Correct — and that is the design. The ten lines are the capture surface, and capture is deliberately thin so it can live inside any agent loop without ceremony. Everything heavy happens on the platform side of the line: sealing, signing, tamper-evidence, packet assembly, Decision Record export, approval routing, precedent indexing.

That split is what makes the compliance story adoptable at all. If capturing a defensible record required rearchitecting the agent, nobody would do it before their first audit — and after the first audit is too late, because records cannot be created retroactively. Ten lines is the price at which teams instrument before they need to.

Diagnostic question: how many lines of code — honestly counted — sit between one of your production agents and its first sealed, signed decision record?

Sources & Further Reading