ARGELLAN / Security Engine
Security Engine
Carry policy through to the point of use.
Security Engine is ARGELLAN’s independent policy-and-enforcement component for information handling. It evaluates a requested action against trusted context and policy, records the exact decision and checks the required conditions when a consumer uses or releases the protected output.
Identity. Policy. Decision evidence.
For application teams handling controlled information
Security Engine is for engineers who need a defensible connection between an access decision and the output an application actually produces. A document label alone cannot govern a search result, a derived artifact or a later export. The decision needs to identify the resource, policy, purpose, destination and required handling actions.
The engine is independently owned and packaged, with public contracts for consumers. Core supplies trusted identity and hosting responsibilities; the application must implement the supported obligations and the final-use boundary for its own output.
From a request to a protected output
Resolve trusted context
Receive a request for an action on an exact resource, with purpose and destination. Validate the trusted context and its identity binding rather than accepting a browser-supplied role as authority.
Evaluate the active policy
Resolve a verified policy snapshot and its dependency-complete package set. Return an evidence-bearing decision with the applicable requirements.
Fulfil the handling obligations
The consumer declares the exact capability it supports and supplies evidence for required handling actions. An ALLOW decision with unmet obligations is not yet permission to release the output.
Recheck at final use
A short-lived protected-use lease binds the decision to the sink. The final-use path rechecks context and output identity and produces a receipt for the protected operation.
Policy and enforcement capabilities
| Exact decision identity | Decision references bind the policy and resource context rather than reducing the result to a bare boolean. |
|---|---|
| Explicit outcomes | ALLOW, DENY and INDETERMINATE preserve the difference between permission, refusal and unresolved authority. |
| Handling obligations | Consumer capability and fulfilment evidence determine whether a permitted decision is ready for use. |
| Final-use control | Short-lived leases and context revalidation address changes between evaluation and release. |
| Markings and derivation | Contracts retain marking and derivation relationships for information created from protected inputs. |
| Audit and recovery evidence | Immutable events, package history, outbox records and reconciliation support accountable state transitions. |
| Administration console | A graphical surface for the policy and administration workflows, with role-scoped access. |
Inputs and outputs
Inputs include trusted context, an exact resource and requested action, purpose and destination constraints, a verified policy package set and the consumer’s supported capabilities. Where the decision requires an obligation, the consumer supplies fulfilment evidence tied to the output.
Outputs include typed decisions and references, required obligations, protected-use leases, final-use receipts and audit/outbox records. Unknown authority or unmet requirements produce a non-permitting result in the exercised paths.
Technical profile and integration
| Packaging | Independent Python engine with consumer-facing contracts and a separate administration surface. |
|---|---|
| Qualified baseline | The first executable baseline was qualified on Ubuntu x86-64. |
| Trusted context | Requires the configured trusted-context provider and identity bindings; the consumer cannot substitute untrusted role text. |
| Application integration | Consumers implement the supported obligation and protected-output contracts. Alpha and Beta synthetic consumers exercised independent integrations. |
| Persistence | Durable SQLite qualification storage is documented. Packaged PostgreSQL migrations do not by themselves establish live PostgreSQL qualification. |
| Administration | HTTP administration routes and a graphical console are documented within the qualified scope. |
| Availability boundaries | Edge/disconnected variants and broad production persistence are separate qualification work. |
| Evaluation scope | Identify the protected actions, output sinks, policy lifecycle, identity source and obligations required by the application. |
Questions about Security Engine
Is an ALLOW decision sufficient to release information?
Not when the decision includes unmet obligations. The consumer must support and fulfil the required handling actions, and the final-use path must still validate the protected operation.
Does Security Engine replace identity management?
It consumes trusted identity context and validates its binding. Authentication and the trusted-context provider remain distinct responsibilities.
Is it a document-classification or redaction service?
It provides policy, marking, obligation and enforcement mechanisms. A consumer must implement the actual handling capability. The demonstrated banner obligation does not establish arbitrary document redaction.
Does it work offline or at a disconnected edge?
The first qualified release was online. Disconnected lease and related Edge behavior remain separate qualification work and need to be addressed for the proposed deployment.
Is KRIL required?
No. Security Engine is independently packaged and was exercised with two separate synthetic consumers. A historical KRIL integration exists, while KRIL’s current standalone direction removes a mandatory shared-engine dependency.
Define the policy boundary your application must enforce.
Tell us what you need to accomplish, the environment you operate and the constraints that matter.
Discuss Security EngineOpens your email application. No message is submitted by this website.