Skip to content
ARF AI
NewBounded write access for ONTAP storage agents, on a simulated cluster

For infrastructure-agent teams

Give production changes a boundary your customer can inspect

Start with one named write path. Map what the agent can change, whether the action can be undone, when a person must approve, and what record remains. Storage first.

Request Pilot Access Console

Mapped to SOC 2 criteria

Each trust services criterion is mapped to the control and code that address it. Not yet audited.

Deterministic enforcement

On a governed path, policy gates run mechanically before an action reaches infrastructure. Not advisory.

Cryptographic audit trail

Every governed decision signed, timestamped and attributed. Exported entries can be verified independently.

Problem

AI agents make autonomous decisions that are difficult to govern, audit, and control.

Solution

ARF applies deterministic policy enforcement before each governed action runs, and refuses the actions it cannot model.

Outcome

Every governed decision becomes explainable, auditable, and operationally trustworthy.

Audience

Who ARF is for

Built for the moment AI agents stop recommending and start acting on production infrastructure.

Platform & SRE leads

You decide what AI-assisted tooling is allowed to do in production, and you need that decision enforced, not just documented.

Founders and CTOs with nobody to delegate this to

A customer's security review asks who governs your agents' actions in production. At thirty people the answer is you — and it has to be something you can show, not describe.

Teams adopting AI-driven operations

You want the speed of autonomous AI without losing the ability to explain, in writing, what happened and why.

Not there yet? The sandbox below is exactly for that — ARF is built for the step after evaluation, not instead of it.

Why ARF?

Foundation models are probabilistic. Enterprise operations require deterministic control. ARF bridges that gap.

Autonomous AI promises unprecedented speed and scale, but without governance it introduces unacceptable operational risk. ARF provides the missing control plane — translating probabilistic model outputs into verifiable, auditable actions that align with your business policies.

Why now?

Autonomous AI is moving from copilots to autonomous workflows. As AI gains the ability to act — not just recommend — organisations need infrastructure that governs execution, manages operational risk, and provides auditability by design.

ARF AI delivers that control plane. Built for the era where AI doesn’t just answer questions — it deploys code, modifies infrastructure, and makes decisions that affect business outcomes.

Built for teams answerable to regulated markets

You may not be the regulated enterprise — your customer is, and their security review is the deadline.

Financial Services
Healthcare
Government & Defence
Critical Infrastructure
Enterprise AI Platforms

Architecture

How ARF works

A recorded run against a simulated ONTAP cluster. Every value shown comes from the run's output.
An AI agent asks to delete the production volume app_data. ARF records the attempt before anything runs, then holds the delete until a storage admin approves it; the agent cannot approve its own request. The approval names app_data only, so a delete of another volume waits again. Once approved, the delete runs and an independent read confirms the volume is gone. A delete ARF cannot model, delete_lun, is refused and never forwarded: zero upstream calls. Every step is a signed, hash-chained record, and editing any entry afterwards makes the chain fail verification.
  1. Application — Any client, any request shape (client)
  2. LLM / AI Agent — Non-deterministic reasoning (probabilistic)
  3. Policies — Matched to tenant rules (matched)
  4. Risk Engine — Explainable scoring (scored 0.31)
  5. Approval — Deterministic gate (granted)
  6. Execution — Runs only once cleared (gated)
  7. Audit Trail — Signed, tamper-evident (signed)

Product

Enterprise capabilities

Four subsystems, one control plane. Explore them on simulated data in the Governance Console; enforcement runs on your agent’s own write path, scoped per engagement.

01

Policy Enforcement

Deterministic policy gates on every governed write.

  • Deterministic execution gates
  • Approval workflows
  • Regional policy controls
  • Cost guardrails
02

Decision Governance

Tamper-evident records with cryptographic signing.

  • Audit trail of every governed decision
  • Cryptographic attestation
  • Attribution & accountability
  • PDF audit report export
03

Continuous Reliability

Proactive monitoring, predictive foresight, and governed recovery actions.

  • Anomaly detection
  • Predictive health scoring
  • Control-theoretic stability monitoring
  • Lyapunov-guided stabilising actions
04

Operational Transparency

Explainable risk scoring, causal reasoning, and real-time observability.

  • Explainable risk scores
  • Counterfactual what-if analysis
  • Live Prometheus metrics
  • Causal attribution

Enterprise-grade governance

The three properties a compliance officer will ask about in the first meeting. Each one is a mechanism, not a policy document.

Tamper-evident audit trail

Every governed decision is recorded, timestamped, and attributed — including the action proposed alongside the one that ran. Anyone holding an export can verify its integrity, for forensic review or compliance preparation.

Mechanical enforcement

On a governed write path, gates cannot be silently overridden: every override is recorded with its approver. Enforcement is deterministic — not advisory.

Explainable reasoning

Every risk score comes with its inputs: the prior, the evidence behind it, and the expected loss of allowing, denying or escalating. Never a black box.

By design · shown on a simulated ONTAP cluster

Every modeled write is checked against whether it can be undone — before it runs, not after.

These are properties of the engine, demonstrated end to end. No customer quotes or numbers appear here until they are real.

What the demo proves

Recorded before it runs
Every modeled write is committed to the record before it executes, then checked by an independent read. A write that read cannot confirm is reported as unverified, not as a success.
Unmodeled writes are refused
A tool ARF cannot model is neither forwarded nor sent for approval — no one is asked to approve what they cannot judge.
One approval, one action
An approval admits exactly the call it was given for: not another volume, and not the same call once its recovery path is gone.

Access models

A free snapshot of five write tools, then a fixed-price review of one agent’s production write paths. A continuous gate is available by invitation after a review.

Sandbox

Simulation only

Free

  • 1,000 evaluations / month
  • Mock responses — not production
  • Community support
Try the sandbox

Pilot snapshot

Free · 3 founding slots

Free

  • One agent, five named write tools
  • Which actions could run unattended
  • In exchange for a written reference
Request Pilot Access

Write-access review

Fixed price · one agent

$4,500

  • Every write path in the agreed tool inventory
  • Unattended vs. approval-required, action by action
  • Explicit gaps, on an agreed delivery date
Talk to us

Explore ARF

The public sandbox returns simulated responses only. Real enforcement is scoped per engagement, on your agent’s own write path.

API

Evaluation endpoint

Send an incident, get a governed decision back.

curl -X POST https://arf-ai-arf-sandbox-api.hf.space/v1/evaluate \
  -H "Content-Type: application/json" \
  -d '{"service_name":"api","event_type":"latency","severity":"high","metrics":{"latency_ms":450}}'

Console

Governance Console

Risk, governance and compliance views on simulated decision data.

Simulation
Console

Specs

Technical specification

Data models, API contracts and decision rules, shared with qualified pilots under written terms.

Core Governance Engine
pilot only
API Control Plane
pilot only
Enterprise Layer
pilot only
Enterprise Specification
pilot only
Request specifications