Making Autonomous Software Execution Independently Verifiable

Archipelo develops Salmon — Execution Verification Infrastructure for establishing cryptographically verifiable execution history and state lineage across agents, humans, and automation.

Explore Salmon

Autonomous software requires verifiable execution history.

Why Archipelo exists

Software Is Becoming Increasingly Autonomous.

The infrastructure beneath it must evolve with it.

Software has historically evolved around human-directed execution. Today, autonomous agents, tools, runtimes, and controllers increasingly perform consequential actions themselves.

Archipelo develops infrastructure that makes autonomous multi-actor software execution independently verifiable — enabling more transparent, accountable, and reliable autonomous systems.

Human

Agent A

Agent B

API

Agent C

Tool

Service

Runtime

State change

The missing property

The Resulting State Does Not Preserve the Execution History that Produced It

As software execution becomes autonomous and multi-actor, the resulting state alone cannot show which execution occurred, in what order, or how each state transition derived from the ones before it.

Software already depends on durable history. Git demonstrates the value of persistent, linked source code history. Execution Verification Infrastructure addresses a different problem: establishing a verifiable record of state transitions and the resulting state.

Logs Telemetry Identity Alerts Metadata ? State S4

What we're building

Execution Verification Is a Distinct Infrastructure Layer

As autonomous software actors become increasingly responsible for consequential execution — durable and independently verifiable execution history becomes foundational infrastructure for systems that investigate, evaluate, govern, and depend upon that execution.

Consequential execution

Execution Verification Infrastructure Capture · Execution Record · State Lineage · Verification

Execution evidence

AI / Agents
Security
Engineering
Audit

Execution record

Execution History Is Established during Execution

Execution is represented as a cryptographically signed event with explicit context. The event records the actor, the action, the state before and after, and the predecessor it links to. Each one can be verified and read in sequence.

Where execution history can be captured during supported execution, downstream systems should not be forced to establish it solely through retrospective inference.

Learn how it works

Representative execution event

{
    "actor": "agent-a1a",
    "action": "write",
    "artifact": "src/auth/session.ts",
    "state_before": "91d7a4e2...",
    "state_after": "a4e8c1f9...",
    "predecessor": "04f7a2e1...",
    "timestamp": "2026-09-13T14:32:08Z",
    "signature": "ed25519:3a...",
    "status": "verified"
}

91d7a4e2 a4e8c1f9 S0

EXEC
04F7A2

Verified

The unique value of execution history

Resulting State ≠ Execution History

Identity: Who or what is acting?
Authority: What may it do?
Policy / Objective: What should it do?
Runtime Security: Should this action be allowed right now?
Observability: What signals did the system emit?
Execution Verification (Salmon): What actually executed, what state did it produce, and can that history be independently verified?

Different properties. Different questions. Execution Verification completes the picture.

Where it applies

Execution Verification Follows
Consequential Execution.

Wherever supported autonomous software execution changes consequential state — preserving a verifiable execution record becomes a foundational systems requirement.

Agent generated changes can involve delegated execution, tools, subprocesses and multiple state transitions. Execution history provides a durable record of supported execution relationships to verify outcomes.

During incident investigation, teams need to work backward from a consequential state change toward the execution associated with it, to determine what caused the outcome.

Human Agent Tool Runtime

$ salmon lineage state:S4

predecessor: S3
event: 04F7A2...
actor: agent-a
action: write
verification: ✓ VERIFIED

What we don't know matters too

Verification Requires Explicit Boundaries

Salmon captures execution as it occurs upstream within supported environments, not downstream after the event has already taken place.

If execution continuity has not been established, Salmon does not visually or structurally manufacture it.

Unaccounted-for state transition

Archipelo and Salmon

One Mission. Two Parts.

Archipelo, Inc. is the company developing and stewarding Salmon. Salmon is the Execution Verification Infrastructure.

The company

Developing and stewarding Salmon for verifiable autonomous software systems.

Execution Verification Infrastructure

Cryptographically verifiable execution history for autonomous multi-actor systems.

Our team

The Team Working at the Systems Boundary.

Protocol architecture, distributed systems, infrastructure, AI systems, and cybersecurity.

Matthew Wise CEO & Protocol Architect
Jason Dusek CTO & Engineering Architect
Paul Calatayud, PhD CISO & Strategy
Jakub Jarzyński Senior Data Engineer
Christophe de Carvalho Senior Backend Engineer
Vasile Staver Senior Product Designer
Stan Kapusta Tech Program Manager
Alex Saifullin Product Manager
Kacper Skawinski Product Lead

Backing

Investors & Advisors

Andy Bechtolsheim Investor
Bill Tai Investor
Jure Leskovec Investor & Advisor Professor of Computer Science, Stanford University
Dawn Song Advisor Professor of Computer Science, UC Berkeley
Anima Anandkumar Investor Bren Professor of Computing at California Institute of Technology