Abraxas for AI Agents

Agentic finance stack

Robinhood's Agentic Trading MCP lets agents trade. Abraxas gives those agents cryptographic proof to check before they move capital or accept an asset.

Abraxas is independent verification infrastructure. not a Robinhood integration. We build alongside the same agentic stack so builders can compose verify → act without rebuilding trust per app.

• Agent receives a task that touches a verified person or RWA (allocation, custody handoff, gated product access).
• POST /api/credentials/verify with record_id or credential. read response.agent.proceed.
• GET response.verify_url. require proof.agent.valid === true (fail closed).
• Only then invoke act-layer tools (e.g. Robinhood MCP order placement) per your policy.

Robinhood reference (act layer). Their Trading MCP is at https://agent.robinhood.com/mcp/trading , OAuth, isolated Agentic account, equities and rolling options support per their docs. Abraxas does not operate that server; compose verify → act in your agent policy.

Design principle

Agents should not have to trust Abraxas. They should be able to verify the proof.

As AI agents begin executing real financial and asset actions, they need more than data. they need independently verifiable proof. Abraxas provides portable, cryptographic verification that agents can check before they act.

Composes with act-layer MCPs (e.g. Robinhood Agentic Trading at agent.robinhood.com/mcp/trading). verify with Abraxas first, then act. Predictable JSON, agent.proceed / agent.valid gates, no UI required.

What Abraxas provides

Abraxas gives AI agents a way to check whether a person or asset has already been verified. without needing the original documents and without trusting a central server's word alone.

Recommended agent flow

• Call POST /api/credentials/verify with record_id, credential_jwt, or sui_address + requested_action
• Read response.agent. check action_allowed and proof_available
• GET response.verify_url (no API key) and read response.agent.valid
• Proceed only when verify agent.next_step is verify_proof AND proof agent.proceed is true

What the agent receives

• Clear decision (approved / denied / manual_review)
• proof_id
• Cryptographic proof it can verify itself
• verify_url for independent validation
• agent.proceed and agent.valid booleans for minimal branching logic

Agent decision fields

Every verify and proof response includes an agent object with explicit booleans , minimal branching logic, no parsing nested receipts.

{
  "verify": {
    "schema": "abraxas.agent.verify.v1",
    "proceed": true,
    "action_allowed": true,
    "decision": "approved",
    "proof_id": "aprx_…",
    "verify_url": "https://…/api/proof/aprx_…",
    "next_step": "verify_proof"
  },
  "proof": {
    "schema": "abraxas.agent.proof.v1",
    "valid": true,
    "proceed": true,
    "signature_valid": true,
    "proof_reliable": true,
    "next_step": "proceed"
  }
}

Decision tree

• verify.agent.next_step === "verify_proof" → GET verify_url, require proof.agent.valid === true
• verify.agent.next_step === "deny" → fail closed
• verify.agent.next_step === "manual_review" → escalate or hold
• verify.agent.next_step === "retry" → approved but proof missing; retry or fail closed
• proof.agent.valid === true → safe to proceed (subject to your policy)

Example integration

// Step 1 — Verify (server-side only)
const verifyRes = await fetch("https://abraxasworld.xyz/api/credentials/verify", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer abx_live_YOUR_KEY",
  },
  body: JSON.stringify({
    record_id: "ABX-RE-HOSP-001",
    policy_id: "abraxas-verify-v1",
  }),
});

if (!verifyRes.ok) {
  throw new Error(`Verify failed: ${verifyRes.status}`);
}

const result = await verifyRes.json();
// result.decision, result.proof_id, result.verify_url, result.authentication_proof

if (result.decision !== "approved") {
  // Fail closed — do not clear the gated action
  return;
}

// Step 2 — Optional: independently confirm the proof (no API key needed)
const proofRes = await fetch(result.verify_url);
const proof = await proofRes.json();

if (!proof.signature_valid || !proof.proof_reliable) {
  throw new Error("Proof signature invalid or proof no longer reliable");
}

// Clear your gated action — user/asset verified with cryptographic proof on record