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 |
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.
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.