Consumption

You have access to the MAP (Multi-Agentic Protocol) institutional substrate.
Documentation: https://docs.multiagentic.dev (and /llms.txt for the directory).

When calling MAP:
- Every call requires (protocol, version, operation, input, tenant_id).
- Capabilities are checked at engine Stage 4 — calls fail with capability_denied
  if your DID lacks the required capability.
- Use map.<protocol>.<operation> as the canonical capability name.
- Heavy reasoning calls (MARC, MACE, MAGI) cost tokens/seconds/watts.
- Cross-organization calls require an active MOAT treaty.
- Refusals are structured — read the `code` and `message` from the error
  envelope before retrying.
- Idempotency-Key is required for safe retries of state-changing operations.

// 1. Read current state
const current = await map.dispatch({
  protocol: 'MIND',
  operation: 'query_knowledge',
  input: { subject: 'treaty_acme_globex', limit: 10 }
});

// 2. Reason
const decision = analyze(current);

// 3. Write (only if needed)
if (decision.should_update) {
  await map.dispatch({
    protocol: 'MIND',
    operation: 'store_memory',
    input: { kind: 'episodic', payload: decision.new_state },
    idempotency_key: `treaty-update-${decision.checksum}`
  });
}

const result = await map.dispatch({
  protocol: 'MARC',
  operation: 'reasoning_task',
  input: {
    intent: '...',
    budget: { tokens: 8000, deadline_ms: 12000 },
    return_fields: ["derivation", "citations", "confidence"]
  }
});

// Verify citations before trusting:
for (const cite of result.citations) {
  const attestation = await map.dispatch({
    protocol: 'MAVEN',
    operation: 'cite',
    input: { source_ref: cite }
  });
  // ... check attestation
}

try {
  await map.dispatch({ protocol: 'MARKET', operation: 'execute_trade', input: ... });
} catch (err) {
  if (err.code === 'policy_denied') {
    // The institution refused with a structured reason.
    // Do not retry the same call. Adjust your plan based on err.message.
    return await adjust_plan(err.message);
  }
  if (err.code === 'rate_limited') {
    await sleep(err.retry_after);
    return retry();
  }
  throw err;
}

const key = `${request_purpose}-${stable_hash_of_input}`;
await map.dispatch({
  protocol: 'MARKET',
  operation: 'execute_trade',
  input: ...,
  idempotency_key: key
});

const audit = await map.dispatch({
  protocol: 'MAX',
  operation: 'audit_query',
  input: {
    correlation_ids: [req1.correlation_id, req2.correlation_id, req3.correlation_id],
    include_inputs: true
  }
});

// Reflect on what you did, reason about whether the outcomes were correct.

// Find out what you can do:
const identity = await map.dispatch({
  protocol: 'MACS',
  operation: 'authorization_request',
  input: { agent_did: my_did }
});

console.log(identity.capabilities);
// → ["map.macs.*", "map.mind.recall_memory", "map.marc.reasoning_task", ...]

const treaty = await map.dispatch({
  protocol: 'MOAT',
  operation: 'compliance_query',
  input: {
    party_a: my_tenant,
    party_b: target_tenant,
    capability: 'map.market.execute_trade'
  }
});

if (!treaty.active) {
  // No treaty. Don't attempt the cross-org call.
  return await escalate(`No active treaty for map.market.execute_trade between ${my_tenant} and ${target_tenant}`);
}

const budget = await map.dispatch({
  protocol: 'MANA',
  operation: 'budget',
  input: { tenant_id: my_tenant, dimension: 'tokens' }
});

if (budget.remaining < estimated_tokens) {
  // Don't start the call; we'll only be refused.
  return await throttle();
}