How It Works
Strix embeds a governance kernel directly into your application's mutation layer. One function call wraps any action with full execution control and an immutable evidence trail.
The integration pattern
Wrap any mutation with governance in a single function call. No refactoring. No separate service. The governance boundary lives exactly where your logic executes.
// Without Strix — no governance
async function deleteResource(id, actor) {
await db.resources.delete(id);
}// With Strix — governed execution
async function deleteResource(id, actor) {
const decision = await strix.govern({
capability: "resources.delete",
actor,
context: { resourceId: id }
});
if (decision.denied) throw new ForbiddenError();
await db.resources.delete(id);
}The governance call evaluates the action, records evidence, and returns a decision before any mutation executes. There is no alternate code path that bypasses evaluation.
The evaluation pipeline
Every governed action passes through four stages. No exceptions. No shortcuts.
The governance kernel intercepts the action before any mutation logic runs. Actor identity, capability, and context are extracted from the request.
The capability is resolved against the registry. Risk tier, approval requirements, and policy rules are loaded. The actor's role and intent are assessed.
The policy engine returns one of three decisions: ALLOW, DENY, or INTERCEPT. This decision is final and non-negotiable for the current request.
The decision, actor, capability, context, and timestamp are written as immutable evidence. This happens for every action, regardless of the decision outcome.
Intent evaluation
Permissions answer who can act. Strix answers whether the action makes sense.
What operation is being performed. The specific capability being invoked and its classification in the registry.
resources.deleteWhy the actor is performing this action. The declared purpose that determines whether the action makes sense in context.
admin cleanupThe circumstances surrounding the action. Resource state, time of day, recent activity, and any relevant metadata.
{ resourceId, status }Full permissions. Clean context. Clear purpose. Permissions allow it — and intent confirms it.
Same user. Same permission. Same action. But the intent targets active resources — operational risk that RBAC cannot see.
RBAC allows both silently. Logging records both after the fact. Strix is the only system that sees the difference before it happens.
Three-state decisions
Every governance evaluation resolves to exactly one of three states. There is no ambiguity.
Proceed with evidence
The action is permitted. The mutation executes normally. The decision and full context are recorded as evidence. This is the default path for low-risk operations performed by authorized actors.
Block execution
The action is forbidden. The mutation handler never executes. A forbidden error is returned to the caller. The denial and the reason are recorded as evidence. The actor is informed but cannot override.
Block until approved
The action is blocked pending human approval. An execution token must be issued before the mutation can proceed. This is for high-risk operations that require explicit authorization before execution.
Capability registry
You define what your system can do. Strix governs how it gets done. Every capability is classified by risk and mapped to a policy.
capabilities: [
{
id: "resources.delete",
domain: "resources",
risk: "critical",
approvalsRequired: 1,
description: "Permanently delete a resource"
},
{
id: "resources.update",
domain: "resources",
risk: "medium",
approvalsRequired: 0,
description: "Update resource properties"
},
// ... your capabilities
]| Risk Tier | Default Policy | Typical Use |
|---|---|---|
| CRITICAL | Deny unless explicitly authorized | Role changes, bulk operations, system configuration |
| HIGH | Intercept and require approval | Deletions, publishing, access modifications |
| MEDIUM | Allow and record | Create and update operations, state changes |
| LOW | Allow and record | Read-adjacent operations, reordering, non-destructive toggles |
You define the capabilities. You assign the risk tiers. Strix enforces the policies and records every decision.
Dual-engine architecture
A local deterministic policy engine runs alongside an optional external SDK. Baseline enforcement continues even when the external engine is unavailable.
Local Policy Engine
- Deterministic, risk-based evaluation
- Zero-latency decisions
- Always available — no network dependency
- Baseline enforcement guarantee
External SDK (Optional)
- Cloud policy evaluation
- Dynamic rules and cross-tenant governance
- Enhanced policy logic beyond risk tiers
- Graceful degradation to local engine
Evidence trail
Every decision is recorded as immutable evidence. Not just approvals and denials — every single governed action, regardless of outcome.
{
capabilityId: "resources.delete"
decision: "INTERCEPT"
actorId: "usr_8f3k2m"
actorRole: "admin"
reason: "High-risk action by authorized actor"
source: "local-policy"
timestamp: "2026-03-20T14:32:01.847Z"
}Complete
Every governed action produces an evidence record. Allowed, denied, and intercepted actions are all captured with full context.
Immutable
Evidence records are append-only. They cannot be modified or deleted after creation. The audit trail is the system of record.
Queryable
Filter by actor, capability, decision, time range, or risk level. Surface patterns across your entire governance history.
Every client, every API, every automation passes through the same governance layer. There is one enforcement boundary. One evidence trail. One source of truth.