OPEN REFERENCE

Ratify Edge Physical AI

Let an agent trigger a physical action while the decision stays on a Linux receiver the actuator cannot overrule.

This is a reference, not a hosted lab. The source and instructions are open and it runs on your machine in minutes. Nothing on this page executes here, and no integration is hosted for you.

Ratify Protocol is an open protocol for proving delegated authority: a principal signs a bounded delegation naming what an agent may do, and any receiver can verify that proof offline, before acting, without calling the issuer. This page is one open reference implementation of it.What Ratify Protocol is ↗

An independent Ratify Protocol project. Experimental, and not a platform partnership, endorsed integration, or safety-certified reference architecture.

Why would a developer or enterprise need this?

Robots, farm equipment, instruments, and edge devices need to decide whether an action is authorized at the point where it has consequences. Network identity and agent-framework permissions are useful controls, but they do not by themselves express which principal approved this exact action, resource, duration, and time window.

Question Network and platform controls Ratify authority
Can this process reach the receiver? Usually yes Not its purpose
Did a recognized principal authorize this action? Not expressed by reachability alone Signed delegation is checked
Is the requested scope and duration within bounds? Often application-specific Receiver evaluates proof and local policy
Can the decision be checked without a network call? Depends on deployment Yes, after proof presentation

Diagram loading…

This matters when an agent can call a tool but must not have unlimited authority: agricultural equipment, warehouse robots, drones, laboratory instruments, charging systems, and other edge-controlled devices. Ratify complements IAM, OAuth, MCP, A2A, and local policy; it does not replace them.

What does this reference do?

The example delegation authorizes a bounded farm action:

scope       physical:actuate
zone        greenhouse-b
resource    irrigation-valve-3
duration    20 seconds maximum
expiry      signed delegation expiry

The current hardware maps that valve action to a short LED command over USB serial. No hazardous device is connected.

Diagram loading…

The Linux receiver is the enforcement boundary. The agent, model, transport, and Arduino cannot turn a denied receiver decision into an authorized decision inside this reference.

Who implements what

Role What it decides or builds This reference uses
Principal Sets the authority ceiling and signs the delegation Ratify SDK or Ratify Verify
Agent operator Presents the proof and action request Deterministic controller or the Google ADK adapter in adk/
Receiver operator Pins the trust root, local policy, and actuator mapping Linux receiver in edge/
Actuator operator Connects and programs the safe output device Arduino sketch in arduino/
Platform vendor No change required to its platform Ratify is independent of an agent framework

The Arduino is an actuator, not the authorization boundary. It does not verify proofs, hold keys, enforce local policy, or provide trusted time. Direct access to the Arduino is outside this reference's security boundary.

What the reference proves

The deterministic gate runs the 16-row protocol matrix and observes the protected effect:

Tested case Decision Actuator handler
authorized actuation authorized invoked
monitor-only request authorized not invoked
replayed proof invalid not invoked
expired proof invalid not invoked
wrong scope invalid or denied not invoked
wrong agent invalid or denied not invoked
revoked certificate revoked not invoked
unavailable revocation state unavailable not invoked

The local gate result is 25 passed, 0 failed, 0 skipped. The final Pi 2 ARMv7 serial integration run for this five-input context implementation also passed: two authorized invocations, monitor authorization without actuation, and replay denial. This is evidence of the receiver-to-actuator path, not a claim that the Arduino verifies authorization.

Run through Google ADK

The deterministic controller above is the default because a gate should not depend on a model behaving. The Google ADK path exists to show the same boundary holding when a real agent framework drives it, and the adapter in ../../adk/edge_agent.py is a real ADK FunctionTool rather than a stand-in.

Four layers, and it is worth being precise about which one decides:

Layer What it does What it can reach
The model (Gemini through ADK) Decides whether to ask for an action and with what zone and duration Two arguments. It never sees the delegation, the proof bundle, or any key
The ADK adapter Requests a challenge, signs the operation context outside model context, presents the proof The agent's private key, which never enters a tool argument or a prompt
The Linux receiver Verifies the signature chain, trust anchor, freshness, scope, zone, duration and local policy, then decides The actuator, and only after an allow
The Arduino Executes a command that already passed Nothing. It verifies nothing and can refuse nothing

The model is not a security boundary here, and nothing depends on it choosing well. A model that asks for the wrong zone, too long a duration, or an action outside the delegation gets the same denial as an attacker would: the receiver never reaches the actuator. That is the point of running the framework path at all.

Setup is in ../../adk/README.md: the pinned environment, the receiver address, and how the authority fixture is issued. The adapter needs the receiver running first, because it asks it for a challenge before it can sign anything.

Which path should I use?

Use this open reference when you need inspectable source, a deterministic local gate, and a safe demonstration of the verification boundary. Use Ratify Verify when you need managed trust configuration, revocation operations, audit retention, observability, availability, and supported deployment adapters.

Run it yourself

Before you start: A Linux machine, a C compiler, make, and the Ratify C SDK. The deterministic gate needs no Arduino, model API, cloud account or trusted clock. The serial path additionally needs a Raspberry Pi 2 or similar ARMv7 device, an Arduino Uno and a USB cable.

Clone ratify-protocol, then from the repository root:

cd references/physical-ai-edge-sentinel
RATIFY_SDK=/path/to/ratify-c ./run-reference-check.sh

25 rows pass with zero failures and zero skips, on ARMv7 hardware as well as locally. On the serial path the actuator fires exactly twice: monitor authorization, replay and every context mismatch leave it untouched.

NEXT

Read the reference, or watch verification run.