Intent

An Intent is the fundamental unit of governance in ΔOS. It represents an agent's request to take a specific action.

What Is an Intent?

An Intent captures everything needed to evaluate whether an action should proceed:

interface Intent {
  id: string;              // Unique identifier
  agentId: string;         // Which agent is requesting
  action: string;          // What action is requested
  resource: string;        // What resource is affected
  parameters: object;      // Action-specific parameters
  context: object;         // Environmental context
  timestamp: string;       // When the request was made
}

Intent Lifecycle

Agent Request → Intent Created → Evidence Collected → Policy Evaluated → Judgment Issued
     ↓                                                                         ↓
   Action                                                                  Allow/Block/Escalate

1. Creation

When an agent wants to take an action, it submits an Intent to ΔOS. This happens before execution, not after.

2. Evidence Collection

ΔOS gathers relevant evidence to inform policy evaluation:

• Historical patterns for this agent
• Current system state
• Relevant thresholds and limits
• Context from integrated systems

3. Policy Evaluation

LIMs (Ledger-Integrated Modules) evaluate the Intent against applicable policies. This evaluation is deterministic—the same inputs always produce the same output.

4. Judgment

The Intent receives one of three Judgments:

• Allow: Action may proceed
• Block: Action must not proceed
• Escalate: Human decision required

Intent Properties

Immutable

Once created, an Intent cannot be modified. Any change requires a new Intent.

Auditable

Every Intent is recorded with its full context and resulting Judgment. This creates a complete audit trail.

Atomic

An Intent represents a single action. Complex workflows are decomposed into multiple Intents.

Intent vs Action

An Intent is the request. An Action is what happens when that request is allowed.

Creating Intents

Via SDK

import { deltaos } from '@deltaos/sdk';

const intent = await deltaos.intents.create({
  action: 'database.write',
  resource: 'users/123',
  parameters: {
    field: 'email',
    value: 'new@example.com'
  },
  context: {
    triggeredBy: 'user-request',
    requestId: 'req-456'
  }
});

if (intent.judgment === 'allow') {
  // Proceed with action
  await updateUser(intent.parameters);
} else if (intent.judgment === 'escalate') {
  // Wait for human decision
  await notifyHuman(intent.escalation);
} else {
  // Action blocked
  logBlockedAction(intent);
}

Intent Structure

Intent Actions

Actions follow a namespace convention:

domain.operation

Examples:

• database.write
• api.external_call
• file.delete
• email.send
• payment.initiate

Standard Actions

ΔOS defines standard actions for common operations:

Custom Actions

Define custom actions for domain-specific operations:

await deltaos.intents.create({
  action: 'trading.place_order',
  resource: 'portfolio/main',
  parameters: {
    symbol: 'AAPL',
    quantity: 100,
    type: 'market'
  }
});

Evidence in Intents

Evidence provides context for policy evaluation:

Automatic Evidence

ΔOS automatically collects:

• Agent reputation score
• Recent Intent history
• Rate limiting counters
• System health metrics

Custom Evidence

Provide additional evidence via context:

await deltaos.intents.create({
  action: 'deployment.release',
  resource: 'production/api',
  parameters: { version: '2.1.0' },
  context: {
    testsPassRate: 0.98,
    canaryMetrics: { errorRate: 0.001 },
    approvedBy: 'release-manager'
  }
});

Querying Intents

By ID

const intent = await deltaos.intents.get('int_abc123');

By Criteria

const intents = await deltaos.intents.list({
  agentId: 'agent_123',
  action: 'database.write',
  judgment: 'block',
  since: '2025-01-01T00:00:00Z'
});

See Also

• Judgments — How Intents are evaluated
• LIMs — Policy evaluation modules
• Evidence — Context for evaluation
• SDK Reference — Full API documentation