Digital Worker Standard

The open standard for governed digital workers.

DWS defines digital workers the way organisations define human roles: with identity, authority, process, verification, and institutional memory. Runtime-agnostic. Framework-agnostic. Built for accountability.

Read the Spec View on GitHub

The Problem

Your agents are capable. Your governance isn’t.

The models are good. The management layer around them is missing. Every organisation deploying AI agents hits the same four problems.

The babysitter tax

If a senior person spends 10 minutes checking 1 minute of AI work, you haven’t saved time. You’ve added a layer. Without authority levels, guardrails, and escalation rules, someone has to watch the machine. That person isn’t cheap.

The amnesia problem

Every session starts cold. Your organisation’s conventions, constraints, and hard-won lessons vanish between runs. You’re re-onboarding the same worker every morning, and they never build up institutional knowledge.

The accountability gap

You can’t see the cost, the logic, or the boundaries. When a worker produces output, there’s no independent evaluation, no audit trail, no structured way to answer “was this good?” Just vibes and eyeballing.

The lock-in trap

Build a worker in one framework and you’re locked in. CrewAI doesn’t port to Claude, LangGraph doesn’t export to Bedrock. Your worker definitions should be portable across any runtime.

The Standard

Everything a hiring manager puts in a job spec has a DWS equivalent.

DWS wraps AI capability in the same professional structure that human employees operate within. Not a framework. Not a runtime. A specification.

What you’d tell a new hire	DWS equivalent
”Your role is contract reviewer”	Worker identity: name, domain, authority level, boundaries
”Don’t touch production”	Boundaries and guardrails: explicit negative scope, input/output validation
”Follow this review process”	Workflow: phased execution with verification and approval gates
”Here’s how we do things here”	Knowledge: conventions, constraints, institutional memory
”Your work gets peer-reviewed”	Verification: independent evaluation by a separate worker
”Get sign-off before publishing”	Approval gates: human authority at decision points
”Show me the audit trail”	Events: structured telemetry for cost, compliance, and learning
”Here’s your budget”	Cost model: per-run and aggregate budget ceilings with alerts

Where DWS Fits

The governance layer the agent stack is missing.

MCP connects workers to tools. A2A connects workers across organisations. DWS defines what a worker is and how it is held accountable.

Tool Access (MCP)

DWS skills reference MCP tools by URI. The runtime dispatches tool calls via MCP. DWS guardrails wrap MCP invocations with authority checks.

Inter-Worker Comms (A2A)

DWS handles coordination within a trust boundary. A2A handles communication across organisational boundaries. Worker Descriptors map to A2A Agent Cards.

Observability (OpenTelemetry)

DWS events are an OTel superset. Every workflow maps to a trace, every phase to a span. Events export to Datadog, Grafana, or any OTel-compatible backend.

How It Works

Define. Validate. Compile. Deploy.

Define

Describe your digital worker in JSON or through a guided interview. Identity, skills, workflow, knowledge.

Validate

Check schema compliance and referential integrity across all definitions. Catch structural issues before anything runs.

Compile

Compile to any supported runtime. One definition, any platform.

Deploy

Run locally, push to Claude Managed Agents, or deploy to your own infrastructure.

terminal

# Create a digital worker through a guided interview
npx dws init ./contract-reviewer

# Validate the definition
npx dws validate ./contract-reviewer

# Compile to a runtime
npx dws compile ./contract-reviewer --target managed-agents

# Deploy
npx dws deploy ./contract-reviewer

The Specification

16 specs across 5 tiers.

DWS v1.0 covers everything from file layout to regulatory compliance. Each spec justifies its existence by being referenced by at least two others.

Foundation

Project structure, manifest format, directory layout, workspace support for multi-worker repos.

Core Primitives

Worker identity, knowledge schema, skills, intent artifacts (work orders in), outcome artifacts (deliverables out).

Orchestration

Workflow phases, multi-worker coordination, independent verification, human-worker interaction, approval gates.

Accumulation

Append-only event stream, OpenTelemetry export, CloudEvents compatibility, structured audit trail.

Governance

EU AI Act mapping, security model, lifecycle management (draft to production to retired), interoperability (MCP, A2A, DID), cost and budget controls.

Start with the spec.

DWS is open source and MIT licensed. Read the spec. Define a worker. Deploy to any runtime.

Quick Start View on GitHub