Connect all your systems from a single chat — with governance

Mahmudur R Manna

mrmanna

Follow

ACM (Agentic Contract Model) v0.5 is a spec-first contract layer and open reference runtime that turns one chat window into your enterprise control surface. Every request becomes a governed workflow: the plan is explicit, execution is policy-checked, and the entire run is replayable for audit and learning. In short: Plan → Execute → Replay → Integrate—safely, across your internal systems and third-party apps. (Why ACM)

Why this matters now: most “chat + plugins” demos don’t survive in production. ACM formalizes typed artifacts (Goal, Context Packet, Capability Map, Plans, Tasks/Tools, Decision Ledger, Replay Bundle) and ships a reference implementation you can run today. (Release Notes)

1) What Agentic Contract Model (ACM) is (and isn’t)

What it is: a contract layer for agentic systems. Requests are turned into typed plans, executed by a deterministic-style runtime under policy gates, with a Decision Ledger & Replay Bundle that preserve every important decision, input, output, and checkpoint.

What it isn’t: a bag of ad-hoc plugins. ACM keeps a curated Capability Map of what’s allowed, the schemas required, and which providers (adapters) may be used. This prevents tool sprawl and keeps chat actions auditable and repeatable. (ACM Core Concepts)

Note for Developers

Start with the Quick Start and run a deterministic example end-to-end (streams, guards, policies, replay).

git clone https://github.com/ddse-foundation/acm.git
cd acm/framework/node
pnpm install && pnpm build

# Run a reference scenario (OpenAI-compatible endpoint, e.g., vLLM)
pnpm --filter @ddse/acm-examples demo \
  --provider vllm \
  --model Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8 \
  --base-url http://localhost:8001/v1 \
  --scenario entitlement

What you’ll see: plan candidates (A/B), guard evaluation, policy hooks, checkpoints, and a generated Replay Bundle. (Quick Start)

2) Problems Agentic Contract Model (ACM) solves for the business

• Unverifiable plans → typed task graphs with rationale and context hashes.
• Opaque execution → append-only ledger of guards, policies, and tool calls.
• LLM drift → deterministic planning with stored alternatives; replays don’t require re-querying the LLM.
• Compliance gaps → policy & verification engines gate tasks; replay bundles ship the full audit trail.
• Failed resumes → checkpointing for long-running flows. (Why ACM)

Note for Developers

Map your terminology to ACM’s artifacts in Core Concepts—Goal, Context Packet (content-addressed), Capability, Task, Tool, Plan, Ledger, Replay. Each is implemented in the v0.5 monorepo packages. (Core Concepts)

3) The four pillars: Plan → Execute → Replay → Integrate

• Plan: the planner emits multiple candidates (Plan-A / Plan-B) with guardable steps and rationale, pinned to a Context Packet and a versioned Capability Map. (Why ACM)
• Execute: the runtime evaluates guards, enforces policies and verification hooks, handles retries/backoff, checkpoints state, and emits a Decision Ledger. (Architecture)
• Replay: export a portable Replay Bundle (plans, alternatives, policy verdicts, ledger, tool envelopes, checkpoints, transcripts) for audit, QA, and analytics. (Why ACM)
• Integrate: reuse existing orchestrators (LangGraph, Microsoft Agent Framework) and retrieval via MCP—without giving up contracts or governance. (Integration Patterns)

Note for Developers

• Architecture at a Glance shows the three-layer intent stack (Planner → Framework → Runtime → Ledger/Replay) and the runtime’s event timeline (PLAN_SELECTED, TASK_START/END, GUARD_EVAL, POLICY_*, VERIFICATION, ERROR/COMPENSATION). (Architecture)
• Integrations page lists bridges (LangGraph, MSAF, MCP) and operational guidelines (keep ledger central, budget third-party calls via Tools, version configs, make replays work across boundaries). (Integration)

4) Governance by design (not as an afterthought)

Policy before action. In ACM, tasks run only after policy returns allow, and that verdict is recorded. Governance targets: traceability, reproducibility, policy compliance, risk containment (versioned catalogs and rate policies so unapproved tools can’t slip into runtime). (Governance)

Clear roles. Platform engineering owns capability maps and replay pipelines; governance/risk defines policies; solution teams publish goals/plans & surface policy needs; auditors validate bundles and re-run deterministic checks. (DDSE Foundation)

Note for Developers

Use the Governance section as your operating manual: Decision Ledger Obligations, Replay Bundle Assembly, Policy and Verification Hooks, Resumable Execution Runbook. Keep governance artifacts (policies, capability maps, retention rules) in source control. (Governance)

5) A mental model for leaders: from “plugins” to contracts

Picture a travel + creative request:

“Find three hotels near SFO for Oct 20–22 under $250, then generate a LinkedIn banner with the chosen hotel.”

With ACM, the chat UI doesn’t “call random tools.” It negotiates a contract: normalize the goal & context, generate Plans A/B (e.g., Booking → then Banner vs. alternate providers), gate each step with policies (budget, residency, brand rules), execute deterministically, and export a replay. The same pattern works for ERP/CRM/Payments because the contract stays stable even if you swap vendors. (Governance)

Note for Developers

The blog blueprint shows capability bindings and a typed task with idempotency, verifications, and compensations—copy-paste these patterns and substitute your adapters. Also see “What ships today” and the implementation checklist to harden your rollout. (Governance)

6) What you can do on Day-1 (realistic, high-value starters)

• Sales/Marketing: create/update CRM opportunities, enforce brand rules on generated assets, log outcomes.
• Finance/Ops: generate POs, route approvals, push to ERP under spend caps.
• Support/Success: open cases, attach incident reports, notify customers, retain a replay.
• HR/People: publish roles with approved JDs, ensure location policies and retention rules apply.

You can run five end-to-end scenarios today—each streams planning, shows policy decisions, and exports replays for QA/RCA. (Examples)

Note for Developers

Use the Scenario Playbook to trial entitlement, knowledge, incidents, invoices, and coaching. Export a bundle and examine plans/, ledger.json, task-outputs.json, and optional checkpoints/.

pnpm --filter @ddse/acm-examples demo -- --scenario invoices --save-bundle --checkpoint-dir ./checkpoints

Adapt the ScenarioDefinition interface to your own flows. (Scenario Playbook)

7) Operating model: how to roll this out safely

1. Publish a Capability Map of allowed actions (schemas, invariants, provider bindings). Keep it versioned. (Architecture)
2. Wrap your systems (ERP, CRM, payments, design) as ACM Tools with declared scopes, rate limits, and verification hooks. (Integration)
3. Author Tasks that own retries, compensations, and guard expressions; attach policy hooks so “retry” obeys governance. (Core Concepts)
4. Stream, Ledger, Bundle: wire your chat UI to stream planner tokens and task updates; persist ledger entries; export replay bundles after each run. (Examples)
5. Forward telemetry to your observability stack and budget dashboards (ledger is first-class). (Integration)

Note for Developers

The Release Notes collect highlights, commands, and known limitations (e.g., adapter resumability parity across external engines is in progress). Treat v0.5.0 as a contract-complete baseline; validate policies and verification hooks in CI. (Release Notes)

8) For technical leaders: architecture & integration stance

• Intent stack: Planner (multiple candidates, context hashing) → Framework (select, wire policies/checkpoints) → Runtime (deterministic execution) → Ledger/Replay. Nucleus governs LLM usage and allowed tools. (Architecture)
• Interoperability, not lock-in: LangGraph & MSAF adapters keep ACM contracts intact while you reuse orchestration investments; MCP brings external context as first-class. Follow the general guidelines: keep the ledger central, wrap third-party calls as Tools for spend/risk budgeting, version configs, make replays work across boundaries. (Integration)

Note for Developers

• Use @ddse/acm-sdk (contracts), @ddse/acm-planner (plans), @ddse/acm-runtime (execution, checkpoints), @ddse/acm-replay (bundle export). The Architecture page maps packages to layers. (Architecture)
• When integrating LangGraph/MSAF/MCP, follow the Integration Patterns playbook to preserve ACM’s governance guarantees. (Integration)

9) Risk, audit, and change control

• Before: policy gates, guard expressions, and allowed capability bindings.
• During: ledger all decisions (plan selected, guard evals, policy pre/post, verification, errors/compensations).
• After: export replay bundles; auditors (or QA) can re-run deterministically with the same Goal/Context/Plan. Store bundles with retention. (Architecture)

Note for Developers

Adopt the Resumable Execution Runbook and Compliance Checklist from Governance; they define responsibilities by role (platform, governance, solution, auditor) and what must be retained. (Governance)

10) Business outcomes to expect

• Speed without chaos: one chat surface, many systems, governed by contracts.
• Audit readiness: action-level provenance and reproducibility.
• Vendor flexibility: swap providers behind stable capabilities (e.g., Figma → Canva) without retraining staff.
• Cost control: budget and observe third-party calls through ACM tools and the central ledger. (Integration)

Note for Developers

Instrument the ledger export path to your monitoring/BI; track policy verdict rates, guard failure hotspots, retry/compensation counts, and per-capability spend. The Scenario Playbook scaffolds these metrics. (Examples)

Try it this week (leaders + devs)

• Leaders: pick 3 high-value actions (e.g., “Create PO,” “Update CRM stage,” “Generate approved banner”). Decide who can run them and where approval is required.
• Devs: register those as Capabilities + Tasks; wire a minimal policy engine; run a scenario and export a Replay Bundle for your next governance review. Use the Quick Start commands above. (Quick Start)

Source & further reading

• Why ACM / Overview — pillars, problems solved, and how the docs are organized. (Why ACM)
• Release Notes v0.5.0 — highlights, quick start, scenarios, limitations, roadmap. (Release Notes)
• Architecture at a Glance — intent stack, artifacts, runtime timeline. (Architecture)
• Core Concepts — typed artifacts and examples in TypeScript. (Core Concepts)
• Governance — decision-ledger obligations, replay bundle assembly, policy/verification hooks, resumable execution runbook. (Governance)
• Integrations — LangGraph, MSAF, MCP, and operational guidance. (Integration)
• Scenario Playbook — five deterministic workflows with streaming and replay export. (Examples)