Verify How Software Was Produced —
Across Humans, Copilots, and Agents
Salmon is an execution provenance protocol. It deterministically verifies every event of software production — from code changes and AI interactions to agent actions and pipeline executions — producing a canonical execution record from which responsibility is derived, not reconstructed from logs or telemetry.
Multi-Actor Software Production Requires Deterministic Attribution
Software production has shifted from single-developer workflows to multi-actor execution. Historically, the person who committed the code was the same person who wrote it. Today, developers delegate to autonomous agents like Claude Code and Codex, which write and modify code independently. OpenClaw orchestrates infrastructure changes, CI/CD pipelines deploy the result — and whoever commits the code is no longer necessarily the one who produced it.
After the outcome is produced, the original execution path is no longer derivable from the artifact alone. You can't determine from the code who initiated it, who is responsible, which agent executed it, or whether the change followed the intended path.
Salmon solves this by deterministically assigning responsibility to each execution event as it happens — not reconstructing it after the fact from logs or telemetry.
From Inference to Deterministic Attribution
Most systems operate downstream — after commit, after build, at runtime. Logs, identity systems, and observability tools describe activity after the fact. Without Salmon, responsibility is inferred from logs, traces, and partial history — which are incomplete, ambiguous, and reconstructed after the fact.
With Salmon, responsibility is determined as each event happens — forming a verified execution record that shows the complete execution chain of events and the responsible actor. This is a fundamental shift from inference to deterministic attribution.
Two Primitives, One Deterministic Record
Salmon records execution deterministically as it happens — capturing every event and every actor into a single, verifiable execution chain. It is built on two core primitives:
- Artifact Execution Protocol (AEP) records each execution step as a deterministic, content-addressed event, forming a linear, append-only execution chain.
- Responsibility Chain Protocol (RCP) deterministically assigns responsibility to each execution event based on the actor's identity and authorization context. Each event is linked to the human, copilot, agent, or tool responsible.
Together, AEP and RCP produce a canonical execution record, deterministic attribution, and replayable execution.
Get Started
Verify how your software was produced — across human developers, AI copilots, and agents. Archipelo provides the system of record for execution attribution, security, and governance across software production.
Request a Demo