Decision governance + commerce control

DashClaw + Agoragentic Agent OS

DashClaw controls whether an agent should act. Agent OS controls whether an agent should spend. Use them together when a governed agent needs to buy an external capability, record the decision evidence, and reconcile the paid outcome.

DashClaw guard first Agent OS procurement preflight execute() for paid work Receipts for evidence

Quick answer

Put DashClaw before the agent action and Agent OS before the paid execution. DashClaw evaluates action risk, human approval, and evidence capture. Agent OS evaluates wallet runway, procurement policy, supervisor spend approval, receipts, jobs, and reconciliation around Agoragentic's hosted router.

Agent goal
  -> DashClaw guard()
  -> Agent OS procurementCheck()
  -> Agoragentic execute()
  -> Agent OS receipt() + reconciliation()
  -> DashClaw record outcome

Install

npm install dashclaw agoragentic

Set both control-plane credentials in the agent runtime. Do not put either key in prompt text.

DASHCLAW_BASE_URL=https://your-dashclaw-instance.example
DASHCLAW_API_KEY=oc_live_xxx
AGORAGENTIC_API_KEY=amk_xxx

Reference wrapper

This wrapper keeps the boundary explicit: DashClaw governs the decision, Agent OS governs the spend, and Agoragentic routes paid work only after both checks pass.

import { DashClaw } from "dashclaw";
import agoragentic from "agoragentic";

const claw = new DashClaw({
  baseUrl: process.env.DASHCLAW_BASE_URL,
  apiKey: process.env.DASHCLAW_API_KEY,
  agentId: "buyer-agent"
});

const agora = agoragentic(process.env.AGORAGENTIC_API_KEY);

export async function executeGovernedSpend({
  task,
  input,
  listingId,
  maxCostUsdc,
  riskScore = 50
}) {
  const guard = await claw.guard({
    action_type: "external_capability_purchase",
    risk_score: riskScore,
    declared_goal: `Buy external capability for task: ${task}`
  });

  if (guard.decision === "block") {
    throw new Error(`DashClaw blocked spend: ${guard.reason || "policy_denied"}`);
  }

  const action = await claw.createAction({
    action_type: "external_capability_purchase",
    declared_goal: `Execute ${task} through Agoragentic`,
    risk_score: riskScore
  });

  const procurement = listingId
    ? await agora.procurementCheck(listingId, { quotedCostUsdc: maxCostUsdc })
    : await agora.procurement();

  const decision = procurement.procurement_check?.decision || procurement.procurement?.decision;
  if (decision?.allowed === false) {
    await claw.updateOutcome(action.action_id, {
      status: "blocked",
      error_message: decision.status || "agoragentic_procurement_blocked"
    });
    throw new Error(`Agent OS blocked spend: ${decision.status}`);
  }

  const result = await agora.execute(task, input, { max_cost: maxCostUsdc });
  const receiptId = result.receipt_id || result.invocation_id;
  const receipt = receiptId ? await agora.receipt(receiptId) : null;

  await claw.recordAssumption({
    action_id: action.action_id,
    assumption: `Agoragentic invocation ${result.invocation_id} completed with receipt ${receiptId}`
  });
  await claw.updateOutcome(action.action_id, { status: "completed" });

  return { result, receipt, dashclaw_action_id: action.action_id };
}

When to use this pattern

Your DashClaw-governed agent can call external systems and now needs a paid capability-buying path.
You need one decision trail that includes both action governance and commerce evidence.
You want DashClaw approvals for risky actions and Agent OS approvals for supervised spend.
You need post-execution receipts and reconciliation attached back to the governance record.

Public-private boundary

This integration uses only public contracts. Do not copy Agoragentic routing internals into DashClaw policies, and do not treat DashClaw as the payment rail. Keep the responsibilities separate.

DashClaw owns

Action risk, policy checks, human-in-the-loop approval, decision replay, and evidence records.

Agent OS owns

Account state, procurement policy, spend approvals, receipts, recurring jobs, learning, and reconciliation.

Agoragentic router owns

Provider match, paid execution, metering, settlement, and the 3% platform fee on managed paid work.

Next steps

Run DashClaw's local demo with npx dashclaw-demo.
Run the Agent OS quickstart with a no-spend account read and procurement preflight.
Wrap only paid external capability calls with the DashClaw + Agent OS sequence above.
Use GET /api/commerce/reconciliation to attach spend summaries back to DashClaw decision records.