AI Action-Sequence Governance

Some attacks are invisible one step at a time. Read a record, then export it, then email it — each action may be individually permitted, but the combination is not. EVE blocks individually-permitted actions that combine into a prohibited sequence.

How sequence governance works

  • Sequence awareness — EVE tracks the ordered actions in a session and evaluates them against forbidden-sequence rules, not just per-action policy.
  • Block on the combination — when the accumulated steps match a prohibited pattern, the offending step resolves to BLOCK even though it would pass alone.
  • Deterministic — the same sequence of actions produces the same decision.
  • Signed evidence — the blocking step can be captured in signed evidence for review.

Evidence example

chain step decision: BLOCK on forbidden combination
# steps 1-2 permitted individually; step 3 completes a prohibited sequence -> BLOCK

SDK context

Sequence state is keyed to the governance session, so pass a stable session_id:

context = {"tenant_id": "org_abc", "principal_id": "agent_flow", "session_id": "sess_seq_1"}
# each eve.govern_tool_call(...) with this session contributes to the sequence evaluation

Readiness

Action-sequence governance is PILOT_READY, part of the pilot-validated core governance architecture (Python; embedded-service mode) and exercised by the agent-governance suite and red-team multi-step chains.

Limitations

  • Sequence state is per-session and in-process in the pilot; durable multi-instance sequence state is a deployment concern that requires a shared store.
  • Sequence rules describe prohibited combinations you configure; they do not automatically infer every dangerous pattern.
  • Enforcement is available in the Python embedded-service mode; wiring it into your agent loop is an integration step.

Next step

Define your prohibited sequences in a pilot and confirm the blocking step with signed chain evidence.

Part of the EVE AI Core control plane Deterministic AI Governance Control Plane → Policy decisions that return the same result for the same input every time, before execution.