RANA: A Verifiable AI Control Room

RANA
TALK
RANA BRAIN

"I think, therefore I am"

Inspiration

AI agents are becoming increasingly capable, but capability creates a new problem: how do we know that an agent actually completed what it claims?

A dashboard may display “PASS,” an agent may report that a file was created, or a long-running task may say it is almost finished. None of these statements prove that the expected artifact exists, that the correct code ran, or that the result was independently verified.

RANA began from a simple principle:

A claim is not evidence, and judgment is not authority.

We wanted to build an AI control room where imagination and autonomous reasoning remain possible, while every real-world action stays bounded, observable, reversible, and accountable to the user.

What it does

RANA converts a human goal into a structured and verifiable workflow:

Observe the current state without assuming that a UI label is true.
Explore multiple possible approaches and failure paths.
Assign bounded tasks with explicit scope, tools, paths, limits, and expiration.
Execute only actions authorized by the user.
Collect evidence such as files, timestamps, hashes, logs, tests, and receipts.
Verify independently so the producer cannot approve its own result.
Preserve history in an append-only evidence ledger.
Promote carefully from candidate results to accepted state only after verification.

The prototype includes:

A local multi-agent control room
Goal and task state machines
Expiring action leases
Producer/verifier separation
SHA-256 artifact receipts
Positive and adversarial test fixtures
Stale-result and duplicate-work detection
Candidate versus accepted-state boundaries
Context migration checkpoints for long-running work
A user-controlled STOP mechanism
A visual observer dashboard

RANA does not treat an AI-generated answer as automatically true. Unknown, missing, stale, or conflicting evidence remains visible as HOLD.

System model

The broader architecture separates three responsibilities:

NARA explores possible futures and solutions.
RARA compares branches and allocates attention and resources.
RANA observes reality, verifies outcomes, and records evidence.

This creates a closed loop:

Human goal
→ possibility expansion
→ bounded task
→ authorized action
→ observation
→ independent verification
→ evidence ledger
→ next decision

The system is designed so that thinking does not automatically become permission to act. An AI may generate questions, hypotheses, judgments, or proposals, but external actions require an explicit user authorization boundary.

How we built it

RANA uses a local-first, evidence-driven architecture composed of:

Python validators and state reducers
JSON Schema contracts
Append-only JSONL ledgers
SHA-256 manifests and receipts
HTML, CSS, and JavaScript dashboards
SQLite-backed local state where appropriate
PowerShell integration for Windows workflows
Deterministic positive and negative test fixtures
OCR and visual-observation experiments for connecting visible UI state to actual evidence

Every important artifact receives a stable identity, producer, verifier, timestamp, status, and cryptographic hash.

We also designed adversarial tests for conditions such as:

Missing artifacts
Incorrect producer identity
Stale revisions
Duplicate task claims
Post-seal mutation
Self-verification
UI-only PASS claims
Interrupted or saturated context windows
Challenges

The hardest challenge was continuity without overclaiming memory.

Long AI conversations eventually reach context limits. Simply starting a new thread can lose important decisions, while copying the entire raw conversation creates privacy and reliability problems.

Our solution was a compact, hash-linked migration checkpoint containing:

Verified artifacts
Preserved failures and HOLD states
Current authority boundaries
Known context losses
Exactly one next action

A successor thread must verify the checkpoint before claiming that context was restored.

Another challenge was preventing multiple agents from silently modifying the same state. RANA addresses this through lane ownership, expiring leases, append-only events, immutable seals, and a single controlled merge owner.

Accomplishments

We are proud that RANA treats uncertainty as a first-class state rather than hiding it.

The prototype can:

Reject unsupported PASS claims
Detect stale or duplicate work
Preserve failed branches as evidence
Verify artifact hashes independently
Continue work across context migrations
Separate AI judgment from action authority
Keep canonical promotion disabled until explicitly approved

Most importantly, RANA keeps the user—not the agent—as the final authority.

What we learned

We learned that trustworthy AI is not created only by improving model intelligence.

It also requires:

Clear authority boundaries
Observable state transitions
Independent verification
Reproducible evidence
Honest uncertainty
Safe interruption and recovery

A powerful agent without these structures can complete impressive work while still leaving the user unable to determine what actually happened.

What's next

Next, we plan to:

Connect every dashboard element to its real evidence source
Expand deterministic runtime tests
Improve cross-platform installation
Add clearer visual explanations for non-technical users
Strengthen privacy-preserving context migration
Test RANA with real multi-agent development workflows
Develop a portable local-first companion interface

Our long-term goal is to create an AI system that can imagine boldly, act carefully, prove honestly, and remain continuously accountable to the people it serves.