Skip to content

minimal-oversight

Uncertainty-aware governed-delegation analytics for delegated AI pipelines.

Companion package to Minimal Oversight: Uncertainty-Aware Governance for Delegated AI Systems (Azevedo, 2026).

Current release: v0.1.2 / minimal-oversight==0.1.2

What problem does this solve?

Delegated AI systems route uncertain work through pipelines: one model proposes, another reviews, a tool checks, and a gate decides what ships. The design problem is no longer just accuracy; it is trust calibration under uncertainty: how much autonomy to grant, where to place oversight, what quality ceiling the system can sustain, and when intervention becomes necessary.

This package turns those questions into computable quantities.

Minimum Sufficient Oversight Principle

The package is centered on the Minimum Sufficient Oversight Principle (MSO): allocate the least sufficient oversight needed to meet a target quality constraint, then concentrate review where it has the highest marginal value. In the paper's Bernoulli/Fisher model, this yields a water-filling rule for review authority rather than a uniform "more oversight everywhere" policy.

Six questions it answers

Question What you get
Can this pipeline meet my quality target? Feasibility check with C_op vs p_min
Where should I place review effort? Water-filling allocation via MSO
Which nodes are most dangerous? Delegation centrality, masking index, SOTA score
How much autonomy can I safely grant? Effective autonomy buffer B_eff
When should humans intervene? Autonomy time T*_auto and intervention schedule
What should stop being delegated? Scope recommendations with coverage constraints

One call

from minimal_oversight import analyze_pipeline
from minimal_oversight.models import Node, PipelineGraph

# Define your pipeline
gen = Node("generator", sigma_skill=0.55, catch_rate=0.65)
rev = Node("reviewer", sigma_skill=0.55, catch_rate=0.65)
pipeline = PipelineGraph([gen, rev])
pipeline.add_edge("generator", "reviewer")

# Full analysis
report = analyze_pipeline(pipeline, p_min=0.80)
print(report)

Or import directly from your framework:

# LangGraph
report = analyze_pipeline(compiled_graph, p_min=0.80)

# Google ADK
report = analyze_pipeline(adk_agent, p_min=0.80)

What it is not

  • Not an agent framework — it analyzes pipelines, not builds them
  • Not a workflow orchestrator — it sits above LangGraph/ADK/CrewAI
  • Not just a plotting library — visualizations serve the decision layer
  • Not the paper's reproduction code — the validation notebook does that separately

It is a governed-delegation analytics and decision-support library, backed by uncertainty-aware and information-theoretic foundations but presented through practitioner questions and one-call analysis.

Architecture

┌─────────────────────────────────────────────┐
│         analyze_pipeline()                  │  ← Practitioner interface
├─────────────────────────────────────────────┤
│  estimation │ capacity │ topology │ viz     │  ← Decision modules
│  allocation │ intervention                  │
├─────────────────────────────────────────────┤
│  _formulae.py                               │  ← Paper equations (private)
├─────────────────────────────────────────────┤
│  schema.py │ connectors/                    │  ← Framework integration
│  langgraph │ adk │ traces                   │
└─────────────────────────────────────────────┘

Two layers: a rigorous core (_formulae.py — every numbered equation from the paper, tested) underneath a practitioner interface (typed reports, human-readable explanations, actionable recommendations). Practitioners never need to touch theorem notation.