Why SREL Matters for Agent Governance

#agents #governance #standards #declarative

Most conversations about AI agents focus on capability: what the agent can do, which tools it calls, how it reasons. Far less attention is paid to a harder question — how do we make the risk of that agent machine-readable and comparable?

This is where SREL becomes complementary to capability languages like ACEL.

Capability vs Risk: Two Missing Standards

Concern	What we need	Current state
What the agent is allowed / designed to do	Declarative capability contract	Emerging (ACEL, Agent Spec, etc.)
How risky that agent is in context	Structured, comparable risk output	Almost entirely free-form (PDFs, slides, spreadsheets)

ACEL answers the first question cleanly: five aspects + autonomy modal + oversight rules, expressed as a versioned contract.

SREL answers the second: a normative grammar so that risk assessments become data instead of documents.

Without the second half, governance stays manual and non-scalable.

The Gap SREL Closes

Today a model risk or agent risk assessment usually ends up as:

A long PDF
A spreadsheet with colored cells
A slide deck for a review committee

None of these can be:

Ingested by a monitoring system
Diffed across versions
Compared across vendors
Automatically escalated when a threshold is crossed
Linked structurally to the controls that are supposed to mitigate them

SREL turns the assessment into a conformant document with required sections, typed values, and semantic invariants. Downstream systems can consume it the same way they consume OpenAPI or SBOM files.

Geometric Structure, Not Just Another Schema

SREL is not “yet another YAML schema for risk.”

It is built on a geometric substrate:

9 dyadic groups × 6 compositional periods = 54 named risk primitives
Each primitive sits at a fixed coordinate
Scores live on an n-simplex decomposition
A meta-condition veto (KILL, SAF, HITL, AUT, TRU, MAN) can collapse the entire composite to zero if structural prerequisites fail

This gives the language two useful properties:

Comparability — two assessments of different systems can be placed in the same coordinate space.
Control linkage — the Controls Exchange profile places controls at the same coordinates as the risks they address. No external mapping table required.

That last point is rare. Most control frameworks (OSCAL, etc.) and risk frameworks live in separate conceptual spaces. SREL deliberately co-locates them.

How This Complements Declarative Agents

Imagine an agent defined in ACEL:

agent research_assistant {
  autonomy: SUPERVISED
  ...
  oversight high_stakes {
    trigger: UNCERTAINTY_ABOVE 0.3
    action: ASK_APPROVAL
  }
}

That contract tells us what the agent is and how it should be governed at runtime.

A corresponding SREL document can tell us how risky the current deployment of that agent is, under real conditions, with a machine-checkable composite score and a clear record of which primitives are driving the risk.

The two artifacts answer different questions:

ACEL → “What is this agent supposed to be and how is it constrained?”
SREL → “Given the current context, how risky is it actually behaving / performing?”

Together they form a more complete governance loop:

Declare capability and oversight (ACEL)
Assess risk in a structured, comparable form (SREL)
Feed the risk output back into monitoring, policy, or human review
Update the capability contract or the runtime thresholds when needed

Practical Implications

If you are building:

Agent platforms → You can emit SREL documents as part of continuous evaluation
Model risk management → You finally have an interchange format instead of proprietary report formats
Monitoring / observability → You can alert on structured bands (WATCH → DRIFT → ELEVATED → CRITICAL) instead of parsing prose
Controls / compliance → You can place controls at the same coordinates as the risks they mitigate

The language is deliberately open (CC0 for the specification text) and designed for downstream consumption rather than for any single vendor’s scoring engine.

Closing Thought

Capability languages make agents describable.

Risk languages make agents governable at scale.

SREL is an attempt to give the industry the second half of that equation in a form that machines can actually use.

If ACEL (or similar contracts) becomes the way we declare what an agent is, SREL is a strong candidate for how we exchange what its residual risk looks like.

Further reading