Autonomous Multi-Agent Coordination Protocol

{
  "decision": "EXECUTE",
  "contractId": "cnt_01hx4k2m9p...",
  "primitive": "microsoft_entra.delete_user",
  "primitiveRiskScore": 165,
  "risk": {
    "level": "critical",
    "minimumHandling": "human_required",
    "reasoning": [
      "destructiveAction",
      "irreversibleWrite",
      "blastRadiusUnbounded",
      "compound:destructive+irreversible",
      "multiplier:blastRadius(1.5x)"
    ],
    "overridePolicy": "escalation_only"
  },
  "expiresAt": "2026-04-01T14:32:00Z"
}

import requests

AMCP_BASE = "https://getamcp.com/api"
API_KEY   = "your_api_key"
HEADERS   = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}


def decide(intent: str) -> dict:
    res = requests.post(f"{AMCP_BASE}/decide", json={"intent": intent}, headers=HEADERS)
    res.raise_for_status()
    return res.json()


def execute(contract_id: str) -> dict:
    res = requests.post(f"{AMCP_BASE}/execute", json={"contractId": contract_id}, headers=HEADERS)
    res.raise_for_status()
    return res.json()


def execute_with_governance(intent: str):
    # Step 1: Resolve intent, receive contract + governance profile
    decision = decide(intent)

    # Step 2: Handle non-execute states
    while decision["decision"] != "EXECUTE":
        if decision["decision"] == "CLARIFY":
            answer = prompt_user(decision["question"])
            decision = decide(answer)
        elif decision["decision"] == "NO_MATCH":
            raise ValueError("Capability not supported")
        else:
            raise ValueError(f"Cannot proceed: {decision['decision']}")

    # Step 3: Inspect governance requirements before execution
    minimum_handling = decision["risk"]["minimumHandling"]

    if minimum_handling == "human_required":
        require_human_approval(decision)
        return None  # execution delegated to approval flow

    if minimum_handling in ("confirm", "strict_confirm"):
        if not confirm_with_user(decision):
            return None

    # Step 4: Redeem contract, receive execution blueprint
    blueprint = execute(decision["contractId"])

    # Step 5: Your code makes the actual API call
    return call_api(blueprint)

async function executeWithGovernance(intent) {
  // Step 1: Resolve intent, receive contract + governance profile
  let decision = await amcp.decide({ intent });

  // Step 2: Handle non-execute states
  while (decision.decision !== "EXECUTE") {
    if (decision.decision === "CLARIFY") {
      const answer = await promptUser(decision.question);
      decision = await amcp.decide({ intent: answer });
    } else if (decision.decision === "NO_MATCH") {
      throw new Error("Capability not supported");
    } else {
      throw new Error(`Cannot proceed: ${decision.decision}`);
    }
  }

  // Step 3: Inspect governance requirements before execution
  const { minimumHandling } = decision.risk;

  if (minimumHandling === "human_required") {
    await requireHumanApproval(decision);
    return; // execution delegated to approval flow
  }

  if (["confirm", "strict_confirm"].includes(minimumHandling)) {
    const confirmed = await confirmWithUser(decision);
    if (!confirmed) return;
  }

  // Step 4: Redeem contract, receive execution blueprint
  const blueprint = await amcp.execute({ contractId: decision.contractId });

  // Step 5: Your code makes the actual API call
  return await callAPI(blueprint);
}

const fetch = require('node-fetch'); // or native fetch (Node 18+)

const AMCP_BASE = 'https://getamcp.com/api';
const API_KEY   = process.env.AMCP_API_KEY;
const HEADERS   = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function decide(intent) {
  const res = await fetch(`${AMCP_BASE}/decide`, {
    method: 'POST', headers: HEADERS,
    body: JSON.stringify({ intent })
  });
  if (!res.ok) throw new Error(`/decide ${res.status}`);
  return res.json();
}

async function execute(contractId) {
  const res = await fetch(`${AMCP_BASE}/execute`, {
    method: 'POST', headers: HEADERS,
    body: JSON.stringify({ contractId })
  });
  if (!res.ok) throw new Error(`/execute ${res.status}`);
  return res.json();
}

async function executeWithGovernance(intent) {
  // Step 1: Resolve intent, receive contract + governance profile
  let decision = await decide(intent);

  // Step 2: Handle non-execute states
  while (decision.decision !== 'EXECUTE') {
    if (decision.decision === 'CLARIFY') {
      const answer = await promptUser(decision.question);
      decision = await decide(answer);
    } else if (decision.decision === 'NO_MATCH') {
      throw new Error('Capability not supported');
    } else {
      throw new Error(`Cannot proceed: ${decision.decision}`);
    }
  }

  // Step 3: Inspect governance requirements before execution
  const { minimumHandling } = decision.risk;

  if (minimumHandling === 'human_required') {
    await requireHumanApproval(decision);
    return null; // execution delegated to approval flow
  }

  if (['confirm', 'strict_confirm'].includes(minimumHandling)) {
    const confirmed = await confirmWithUser(decision);
    if (!confirmed) return null;
  }

  // Step 4: Redeem contract, receive execution blueprint
  const blueprint = await execute(decision.contractId);

  // Step 5: Your code makes the actual API call
  return callAPI(blueprint);
}

module.exports = { executeWithGovernance };