All projects
Project 02 · 2026

Avaira Protocol

“Unknown is a useful answer when the evidence is thin.”

An experiment in making agents pause when they are unsure

Instrument readout
> prove ....... SAFE
> witness ..... none
> cost ........ $95 < $100
> gate ........ OPEN
Project
02
Category
Agent infrastructure
Year
2026
Status
Experimental
License
Repository
Built with
Python · OPA
The problem

I wanted to explore a less comfortable question: what should an AI system do when it cannot tell whether an action is safe?

Avaira is a place to test that idea. It separates planning, checking, simulation, and execution instead of letting one confident answer do all four jobs.

The project is still experimental. I am more interested in learning where the design breaks than in presenting it as a complete safety system.

How it works

The order matters. Each step is what earns the next one the right to run.

  1. 01

    Reason, with a trace

    A System-2 planner refuses to emit a plan without a complete reasoning trace. Working memory is capped at 7±2 slots with a protected goal chunk.

  2. 02

    Prove it, or don't

    An interval-arithmetic symbolic prover returns SAFE, UNSAFE with a witness, or UNKNOWN. UNKNOWN fails closed.

  3. 03

    Simulate it

    A seeded 200-run Monte-Carlo shadow sandbox exercises the plan before anything is allowed near real state.

  4. 04

    Gate it

    Execution requires attestation plus an HMAC-signed SAFE certificate bound to the plan hash, and a worst-case cost under the cap.

  5. 05

    Settle it

    Violations settle atomically against a staked ledger via a freeze-and-slash adapter. The ledger is hash-chained and tamper-evident.

Claims

Claims, and how you'd check them

A claim without a way to test it is marketing. Each of these has a method.

Safety is proven before execution, not asserted after

check · Interval-arithmetic prover, strict three-way verdicts

The gate is a strict boolean, not a confidence score

check · Attestation + signed certificate bound to the plan hash + cost cap

Memory writes need artifacts

check · Self-editing memory rejects artifact-less writes; reversals need higher confidence or two independent artifacts

The same input produces the same output, byte for byte

check · CI re-runs the demos twice and asserts byte-identical results

What it doesn't do

The scope of a tool is part of its honesty. These are the edges of Avaira Protocol, stated by the person who wrote it.

  • The proven-safety claim covers the kernel's own reasoning, not the correctness of your policy set
  • Deterministic and offline by design — it is not a hosted service
  • Settlement adapters are illustrative of the ledger design, not an audit of any chain
Read the sourceAll projects
Next project

NGS-Agent / GeneOS

A bioinformatics side project for reading sequencing run evidence