MOSS

Unsigned agent output is broken output.

MOSS (Message-Origin Signing System) provides cryptographic signing for AI agents. Every output is signed with ML-DSA-44 (post-quantum), creating non-repudiable execution records with audit-grade provenance.

ML-DSA-44 Parameter Sizes (FIPS 204)

Install

pip install moss-sdk

Quick Start

MOSS works out of the box with zero configuration. No API key required for local signing.

from moss import sign, verify

# Sign any agent output (keys generated automatically)
result = sign(
    output={"action": "transfer", "amount": 500},
    agent_id="agent-finance-01",
    context={"user_id": "u123"}
)
# [MOSS DEV MODE] Keys stored locally in ~/.moss/keys/
#   Run log: ~/.moss/run.jsonl
#   Verify: moss verify-log ~/.moss/run.jsonl
#   For production (KMS, policies, audit): set MOSS_API_KEY

# result.envelope: MOSS Envelope with signature
# result.signature: ML-DSA-44 post-quantum signature
# result.allowed: True (or False if enterprise policy blocks)

# Verify offline - no MOSS servers required
verify_result = verify(result.envelope)
if verify_result.valid:
    print(f"Signed by: {verify_result.subject}")

# Verify all signed actions
moss verify-log ~/.moss/run.jsonl
# ✓ 47 valid, ✗ 0 invalid

Local Mode (Default)

When no MOSS_API_KEY is set, MOSS operates in local mode:

Configuration

Verifying Run Logs

# Verify default run log
moss verify-log

# Verify custom log file
moss verify-log /path/to/custom.jsonl

# Show details for invalid entries
moss verify-log --strict

# Quiet mode (summary only)
moss verify-log -q

Enterprise Mode

Set MOSS_API_KEY to enable enterprise features:

import os
os.environ["MOSS_API_KEY"] = "your-api-key"

from moss import sign, enterprise_enabled

# Check if enterprise mode is active
print(f"Enterprise: {enterprise_enabled()}")  # True

# Sign with automatic policy evaluation
result = sign(
    output={"action": "high_risk_transfer", "amount": 1000000},
    agent_id="finance-bot",
    action="transfer",
    context={"user_id": "u123", "department": "finance"}
)

if result.blocked:
    print(f"Action blocked: {result.policy.reason}")
else:
    print(f"Action allowed, evidence_id: {result.evidence_id}")

Execution Record Format

Every signed action produces a verifiable execution record:

agent_id:      moss:agent:agent-finance-01
action:        transfer
timestamp:     2026-01-18T12:34:56Z
sequence:      42
payload_hash:  SHA-256:abc123...
signature:     ML-DSA-44:xyz789...
status:        VERIFIED

Using Subject (Advanced)

from moss import Subject

agent = Subject.create("moss:dev:my-agent")
envelope = agent.sign({"action": "approved", "amount": 500})

result = Subject.verify(envelope)
assert result.valid

SDKs

TypeScript Example

import { sign, verify } from '@moss/sdk';

const envelope = await sign({
  output: agentResponse,
  agentId: "agent-finance-01"
});

const result = await envelope.verify();

Go Example

client, _ := moss.NewClient(moss.Config{APIKey: os.Getenv("MOSS_API_KEY")})
result, _ := client.Sign(moss.SignRequest{
    Payload: map[string]any{"action": "transfer", "amount": 500},
    AgentID: "agent-finance-01",
})

Framework Integrations

Protocol Integrations

UCP (Universal Commerce Protocol)

Sign Google/Shopify agentic commerce operations with MOSS provenance:

pip install moss-sdk[ucp]

from moss.integrations.ucp import MOSSUCPClient

client = MOSSUCPClient(
    business_url="https://merchant.example.com",
    agent_id="shopping-agent-01"
)

# Every operation is automatically signed
checkout = await client.create_checkout(
    line_items=[{"id": "sku_123", "quantity": 1}],
    currency="USD"
)

# Verify the signature
assert checkout.verify()
print(f"Checkout {checkout.id} signed: {checkout.envelope.signature[:16]}...")

# Complete with payment - signs both request and response
completion = await client.complete_checkout(
    session_id=checkout.id,
    payment_data={"method": "card", "token": "tok_xxx"},
    ap2_mandate={"consent_id": "..."}
)

Why MOSS + UCP? UCP's AP2 mandates prove user consent, but don't prove which agent performed the action. MOSS fills this gap with cryptographic provenance.

ACP (Agentic Commerce Protocol)

Sign OpenAI/Stripe agentic commerce operations with MOSS provenance:

pip install moss-sdk[acp]

from moss.integrations.acp import MOSSACPClient

client = MOSSACPClient(
    merchant_url="https://merchant.example.com",
    agent_id="commerce-agent-01"
)

# Create checkout - automatically signed
checkout = await client.create_checkout(
    items=[{"name": "Blue T-Shirt", "price": 2999, "quantity": 1}],
    currency="usd"
)

# Verify the signature
assert checkout.verify()

# Complete with Stripe payment token
completion = await client.complete_checkout(
    session_id=checkout.id,
    payment_token="spt_xxx"  # Stripe Shared Payment Token
)

if completion.success:
    print(f"Order {completion.order_id} created")

Why MOSS + ACP? ACP's Delegated Payment Spec handles secure token passing, but doesn't prove which agent initiated the checkout. MOSS adds cryptographic provenance for complete audit trails.

CLI

# Create a new subject
moss subject create moss:dev:my-agent

# Sign a payload
echo '{"action": "test"}' | moss sign moss:dev:my-agent - > envelope.json

# Verify single envelope
moss verify payload.json envelope.json

# Verify entire run log (local mode)
moss verify-log ~/.moss/run.jsonl
moss verify-log --strict  # show details for failures

# Compare two envelopes
moss diff envelope1.json envelope2.json

What MOSS Provides

Regulatory Compliance

MOSS automatically collects evidence for regulatory compliance:

Evidence Types

MOSS collects 27 types of compliance evidence automatically:

• Audit logs, decision traces, policy attestations
• Human oversight records, approval workflows
• Risk assessments, anomaly detection, drift monitoring

Free Regulatory Scan

Discover applicable AI regulations for any domain:

curl -X POST https://api.mosscomputing.com/v1/regulatory/scan \
  -H "Content-Type: application/json" \
  -d '{"domain": "your-company.com"}'

Pricing

All new signups get a 7-day free trial with full platform access.

What's Included

See iampass.com/pricing for details.

Protocol

MOSS implements moss-0001. See SPEC.md.

Envelope

{
  "spec": "moss-0001",
  "version": 1,
  "alg": "ML-DSA-44",
  "subject": "moss:acme:order-bot",
  "key_version": 1,
  "seq": 42,
  "issued_at": 1733200000,
  "payload_hash": "<base64url(SHA-256(canonical(payload)))>",
  "signature": "<base64url(ML-DSA-44 signature)>"
}

Verification

1. Check spec == "moss-0001"
2. Compute hash = base64url(SHA-256(canonical(payload)))
3. Assert hash == envelope.payload_hash
4. Resolve (subject, key_version) → public_key
5. Verify ML-DSA-44.verify(public_key, canonical(signed_bytes), signature)

Cryptography

Keys stored at ~/.moss/keys/. Set MOSS_KEY_PASSPHRASE to encrypt at rest.

Links

• mosscomputing.com — Project site
• dev.mosscomputing.com — Developer Console
• audit.mosscomputing.com — Authority Vault (compliance)
• SPEC.md — Protocol specification
• PyPI — Package

Telemetry

MOSS collects anonymous, privacy-respecting usage data to improve the SDK:

What we don't collect: Payloads, agent IDs, signatures, keys, or any PII.

Opt Out

# Standard opt-out (respected by many tools)
export DO_NOT_TRACK=1

# MOSS-specific opt-out
export MOSS_DISABLE_TELEMETRY=1

Check Status

from moss.telemetry import get_telemetry_status
print(get_telemetry_status())
# {'enabled': True, 'install_id': 'abc-123-...', 'sign_count_today': 42}

Contributing

See CONTRIBUTING.md.

Security

Report vulnerabilities to moss@iampass.com. See SECURITY.md.

License

MIT - See LICENSE for terms.