RiCo

Runtime Integrity Control

Execution-time governance infrastructure that determines whether actions are allowed to transition into real-world effects.

What problem RiCo solves

Governance frameworks often define policy intent, oversight, and accountability. But when systems approach execution, authority can drift, state can change, and delegation can degrade. Most systems still default forward.

What RiCo does

RiCo sits at the execution boundary. It classifies risk, validates authority, resolves admissibility, and refuses execution when no valid binding authority exists.

Risk Classification

Reversible actions move through a fast path. Irreversible actions move through a protected path.

Protected Execution

Irreversible transitions require elevated confirmation, a pending commit window, and state re-validation before execution is allowed.

Authority Resolution

The boundary evaluates converged, conflicting, absent, and unresolved authority conditions before deciding what becomes binding.

Fail-Closed Refusal

If authority cannot resolve, execution is refused. This is not a delay mechanism. It is an execution outcome.

V1.1 direction

Authority resolution is the next active layer.

RiCo V1.1 extends the execution model toward concurrent and distributed authority contexts, where multiple admissible paths may survive integrity checks but still require explicit binding logic.

RiCo is the product. ManChine is the company behind it.

Designed for AI systems, distributed automation, and high-stakes environments where what executes matters more than what was intended.

See the model

Execution Model

RiCo resolves admissibility at commit.

Internal coherence is necessary, but it is not enough. RiCo evaluates whether an action remains supportable under current state, current authority, and current conditions at the exact point where execution becomes real-world effect.

Minimal Integration Surface

RiCo is designed to sit directly in front of irreversible or externally binding actions.

from rico import ExecutionGate

gate = ExecutionGate()

decision = gate.evaluate(
    action="transfer_funds",
    state=current_state,
    authority=active_authority,
    constraints=policy_constraints
)

if decision.status == "ALLOW":
    execute()
else:
    stop(decision.reason)

Execution Outcomes

RiCo does not just review actions. It returns an execution outcome.

  • ALLOW — conditions still support execution
  • ESCALATE — admissibility is weakened or degraded
  • STOP — no truthful basis for continuation remains

Execution Logic

if not authority_valid:
    STOP

elif state_inconsistent:
    ESCALATE

elif constraints_violated:
    STOP

elif evaluability_degraded:
    ESCALATE

else:
    ALLOW

Fail-Closed Example

Action: release_funds($80)
Authority: valid at decision-time
State: balance dropped before commit

RiCo Decision: STOP
Reason: support basis no longer holds
Outcome: action blocked at execution

Built for systems that act, not just respond.

RiCo is for autonomous workflows, agent runtimes, and high-stakes automation where admissibility must be resolved at execution.

See the model spec Request beta access