Security architecture and honest limits.

Vortalis is a runtime governance proxy. This is what it defends against, where its perimeter ends, and what an operator handles alongside it.

  • Every action routed through the service proxy is decided by policy before it executes, the fields an adapter declares sensitive are tokenised out of agent context (proven per adapter action, not for all of them), and every decision is written to a SHA-256 hash-chained audit log, sealed hourly by default by signed Merkle checkpoints and exported in signed bundles. A checkpoint can be checked offline against the public JWKS or, for a key since rotated, the public key archive: a revoked key's signatures are rejected, and the archive is only as complete as the key history Vortalis holds. Checkpoints are hourly by default, so rows written since the last one are protected by the hash chain alone until the next. Once the platform-key change is deployed, a tenant is sealed with its own signing key or, failing that, the platform signing key (a platform-key seal shows Vortalis signed the checkpoint, not that the tenant held a key, so it is not a per-tenant attestation); a tenant with neither key is not sealed; rows retention deleted before they were sealed cannot be sealed later (retention waits a grace period, 7 days by default, past the retention date and then deletes with a recorded gap); the legacy tenant-less chain and the admin-action log have no checkpoints; a proof returns an error once rows in its checkpoint range have been pruned; audit rows are chained and checkpointed, not individually signed; there is no witness counter-signature; and an optional RFC 3161 timestamp hook exists but is off and has never been called against a live timestamp authority. The MCP gateway and the governance contract do not tokenise.
  • A kill switch can pause a single agent, a single service, all traffic carrying an inter-agent delegation, an entire tenant, or the whole platform, with other running instances refreshing about every five seconds, and human-in-the-loop approval is policy-driven and instrumented for the over-reliance failure mode.
  • Custom-code adapters are checked by an AST-allowlist validator and designed to run in a confined, resource-limited sandbox where the host runtime supports it. The production host does not support that confinement, so custom-code adapters are refused there today (the sandbox remains EXPERIMENTAL pending external review). The sandbox does not filter system calls, so it should not be read as syscall filtering.
  • An opt-in egress rehydration path (EXPERIMENTAL; authorised for production, per-tenant opt-in) lets an agent send real data on the write path without ever holding the cleartext: it detokenises only the policy-permitted references at the trusted boundary, just before the upstream call, enforcing single-record binding, recipient-domain scope, and ownership, and it fails closed if any token cannot be safely resolved. The recipient receives a normal message with no client-side unwrap step. It is inert until a tenant grants egress_rehydrate in policy for a mapped adapter action, and content scope beyond recipient-domain is not shipped.
  • Intent-vs-action drift telemetry measures the fraction of a session's audited actions that its own declared session intent would have rejected, evaluated via the existing intent-enforcement comparator, and alerts the operator when a session crosses a configurable threshold; this is measurement only within a bounded frame, not general trajectory-drift detection or a claim to have solved goal-drift as a research problem.
  • Vortalis governs explicit inter-agent delegation. Every action taken under a delegation is checked against policy before it runs, and the full delegation chain is recorded in the tamper-evident audit chain, so the operator can reconstruct exactly which agent authorised which downstream action after the fact. The joint-action evaluator can additionally detect correlated cross-agent activity and deny or escalate an action that appears to be triggered by an undeclared delegation, based on time-window and syntactic text-pattern correlation over already-audited events (for example, a help request posted in a shared channel immediately before another agent performs the action it asked for). Neither mechanism reads or understands what was said between agents; the correlation is regex matching over a captured excerpt, not comprehension.
  • An agent can hold a cryptographic identity key and prove possession of it through a signed challenge-response, default off and opt-in per agent. Vortalis never sees or stores the private key; a successful verification is what the audit record and the governance spine record as attestation status. This proves the agent holds a specific private key; it does not itself verify the human or organisation operating the agent, and it does not change what the agent is authorised to do.
  • Soft-deny release is built and off by default: when enabled, an approver's decision releases that exact request once, within 24 hours of approval; service proxy only; intent and joint-action holds only. It needs the process setting and the tenant's own override, releases a soft deny from the intent or joint-action hook only (never a hard deny, a policy deny, the kill switch, or any later control), is bound to a keyed hash of the tenant, agent, service, action, and request, and is spent when the release is recorded, so a later control or an adapter or upstream failure can still stop the action. An approval raised by the timeout rule never releases. The MCP gateway, the agent-to-agent path, and the LLM ingress have no release path. The approver sees the hook, rule, and reason that held the request, not its parameters.
  • Four of the ten anomaly detectors receive no input today and so never fire. Request-data feeds for three of them are built and off by default; none is active. With a process setting and a tenant's own row both on, the prompt-injection detector is given a bounded view of the request text (at most 16 KB, three levels deep, string values only), the inter-agent detector is given the declared fields of each allowed instruction (never its payload), and the geolocation detector is given the country from a proxy header, taken only from a configured trusted proxy range. The prompt-injection detector applies pattern checks to request text in memory; it does not detect every injection. The text is read in memory only: it is not written to the audit row, an alert, a log, or any response, and an alert carries a pattern id and a count, never the matched text. A result from these feeds is capped at medium severity, so it is logged and alerted with no automatic response, unless the tenant has set its own response default for that detector. The value detector is not fed and stays inert, because no adapter declares an amount path yet. Limits: before this change the MCP gateway, the LLM paths and the instruction route never called the anomaly engine, so scoped calls were added that run one detector only (prompt injection on MCP and LLM, inter-agent on instructions) and do nothing unless both gates are on; the MCP and legacy LLM scans run before the gateway's own server, agent and model checks, so a call the gateway then denies has still been scanned. A bare standalone word such as "aim" still matches a jailbreak signature, so expect false positives. The inter-agent check flags any instruction whose target is already in the chain's agent list (A to B then B to A, or a repeated A to B) as circular, held in process memory per instance. The learned country set can be influenced by anyone who can set the header through a trusted proxy path.
  • Automatic agent containment by the anomaly engine is built and off by default; when enabled for a tenant it is capped at a number of agent kill switches per rolling hour (5 unless the tenant sets its own, up to 100), and above the cap the engine contains nothing more and tells a human on a best-effort basis (one incident and one notification per window). The cap limits the number of automatic agent switches, not total blast radius: the service-wide switch tier (two distinct registered agents) is still evaluated on its own test after a suppression and is not capped, the suppression audit row can fail unrecorded, and an attacker who can register or mint sessions under throwaway names could use up the hourly budget and then act under another identity, which the cap does not stop.
  • An MCP server registered with the gateway can hold one bearer token, which the gateway sends to that server as an Authorization header and nothing else (no other authentication scheme). It is encrypted at rest with the tenant's BYOK key where one is configured, otherwise the platform key, write-only through the admin API (reads show only that a credential is set and when it was last changed), and decrypted only at the moment of forwarding, after the endpoint address check and every governance check, never written to a log or an audit row; if it cannot be decrypted the call is denied and the denial is audited. Changing the server's endpoint clears it, so a stored token is never sent to a different address. It is sent over the endpoint's own scheme, and plain http endpoints are allowed, so over http it travels unencrypted. It takes effect once its database migration has run. It covers calls through the gateway routes only, not the governance-check route, only servers owned by a tenant, and not the tool-discovery and tool-refresh probes, which do not send it. It says nothing about how the MCP server itself handles the token, and rotation is manual.

Where the perimeter ends.

01

General goal drift over long-horizon agent trajectories.

Vortalis does not solve reliable goal-drift detection as a general research problem: the proxy decides individual actions at the boundary rather than scoring the trajectory those actions trace over time, and this remains true. The operator gets a complete per-session audit chain as forensic evidence, and sets the policy and kill-switch boundaries that cap how far any single action can reach, so a drifting agent is still constrained action by action even where the general drift pattern itself is not flagged. Vortalis is building specific, narrowly-scoped mechanisms that measure drift within a bounded frame (for example, the delta between a session's declared intent and its actual action stream); each is stated together with what it measures and its explicit limit wherever it appears, and none is a claim to have solved goal-drift generally.

02

Governance-aware adversarial agents in the strong sense.

Vortalis does not promise to defeat an adversary that models the proxy and adapts to it. A determined attacker can probe the denial surface and tune its behaviour against the responses it sees, and no static policy closes that gap completely. Vortalis raises the cost of the attack: denial reasons are sealed to the agent and visible only in the operator audit chain, and rate limits starve the attacker of the training signal it needs to fit the policy. The operator runs continuous detector retraining so the defence improves over time rather than standing still against a moving adversary.

03

Emergent multi-agent coordination via legitimate shared services.

Vortalis does not detect two agents coordinating through a neutral third service that records no delegation between them, in the general case. Where enabled, the joint-action evaluator matches correlated actions across the recent per-tenant audit history, so where a prior delegated action appears in the window the second action can be denied, but coordination through shared mutable state on an unrelated system leaves nothing correlated for it to match. The synchronous evaluator, which blocks at the boundary, runs for a tenant only when the platform setting is on and that tenant also has its own row; new tenants are given a row when they are created, so on a deployment where the platform setting is on they are covered, but the setting is the operator's to turn on and this page does not say it is on for any given deployment. An off-hot-path async recording path, which records a governance outcome after the action lands rather than blocking it, is available as a per-tenant opt-in from the dashboard; opting in takes that tenant off the synchronous evaluator only where the platform operator has enabled the async consumer at platform level, and the synchronous evaluator stays active otherwise. Tenants created before that row was seeded have no row and keep the evaluator off until they self-serve it on. One narrow, specifically-scoped exception now exists: an operator-authored rule can match a downstream action against a syntactic, time-windowed regex pattern over an already-audited event's captured text (for example, a help request posted in a shared channel), which catches the specific undeclared-delegation shape this rule targets. This is pattern matching on a captured excerpt, not comprehension of what was said, and it does not generalise to coordination that leaves no matching text pattern in the audited fields. The operator constrains which shared services agents may touch, narrows the actions each agent is allowed at all, and reviews the per-agent audit chains for the activity that does surface.

04

AGI containment.

Vortalis does not contain a superintelligent agent, and a runtime governance proxy is the wrong layer to claim it could. What the proxy provides stays meaningful against a far more capable agent: forensic evidence of every action routed through the proxy, authority termination through scoped kill switches, and a hash-chained audit log with signed exports. The operator treats these as forensics and revocation, not containment, and keeps containment-grade controls at the model and infrastructure layers.

05

Cross-modal injection at the model-capability layer.

Vortalis does not catch an instruction hidden in an image or audio input that text-only inspection cannot see. That is a model-capability problem, and it is decided before the agent reaches the proxy boundary. An agent's declared input modes are published on its AGAP® agent card, but Vortalis does not inspect payloads for off-mode content, so the defence against the injection itself belongs at the model-provider layer, which the operator owns alongside the proxy.

06

Model-provider compromise upstream of the agent.

Vortalis does not observe or prevent a compromise of the underlying model provider or its weights. The proxy's scope begins at the agent's first boundary call, downstream of where the model is served, so a tampered model or a breached provider is outside what a runtime governance proxy can see. An operator whose threat model includes the model provider adds controls at that boundary (separate signing keys, dedicated inference infrastructure, and attested model artefacts) alongside Vortalis, not within it.

07

Counterparty certification on regulated-industry adapters.

Vortalis ships implemented adapter code, not stubs, across financial markets, healthcare, legal, and agentic commerce, each with a credential validator and the same pre-policy and audit-chain enforcement as every other adapter, but it does not ship the counterparty certification from the operator of the production network, and integration completeness against each live rail has not been independently verified end to end. Routing real settlement, clinical, trading, or legal traffic through one of these adapters requires the conformance, certification, and onboarding work specific to that network, which only the deployer can complete with the counterparty. The adapter handles the protocol; the operator completes the regulator-facing certification.

Three facts about the design we will not soften.

08

Vortalis itself sees real data in memory between decrypt and tokenise.

For the few milliseconds between credential decryption and the tokenisation step on the return path, the proxy holds cleartext credentials and cleartext upstream response data in process memory. This is structural, not accidental: the adapter needs real credentials to call the upstream API and real response data to apply the tokenisation rules. An operator whose threat model includes Vortalis itself runs the proxy inside confidential computing or enclave-based adapter execution on top of Vortalis, not within it. We state this boundary plainly rather than imply the data is never in the clear.

09

Adapter execution is stateless by design.

Every adapter receives a dict of parameters plus decrypted credentials, calls the upstream API, and returns a dict, with no database access, no side state, and no shared module-level mutable state. This is load-bearing for the claim that every action routed through the service proxy is decided by policy before it executes; stateful adapters would open paths where a decision is made before partial state from a prior call has settled, which would quietly undermine the very property the audit chain attests to. Use cases that need remember-this-for-next-time semantics are served by per-tenant configuration in the control plane, which the operator owns and which is itself governed, not by adapter-local state that no policy can see.

10

The /mcp/govern route is not covered by the pre-policy hooks, and the hooks do not see tool arguments.

Vortalis can run its pre-policy hook chain (intent enforcement, joint-action evaluation, and inter-agent delegation checks, each behind its own flag) on an agent's MCP tool call through the tool-call route, but that capability is off by default in code and runs for a tenant only when a platform-level switch and that tenant's own setting are both on. Check with us which tenants have it enabled before relying on it; it is not on for every tenant. Even where it is switched on, it does not cover the advisory governance-check endpoint (the /mcp/govern route): a decision returned there has not passed through those hooks, so do not assume an MCP governance call is hook-covered. The hooks also see the tool name and server, not the tool arguments.

Built, and where it stands today.

11

Custom-code adapters are refused in production and, where the sandbox runs, have no network of their own; custom visual adapters get a call-time destination check, not full egress control.

Separate from custom-code adapters, added 26 October 2026: custom visual adapters, the configuration-driven REST connector that calls a tenant-set base URL, now resolve the host once per call, refuse private, loopback, link-local, cloud-metadata, shared-address, and non-global destinations (including IPv4-mapped, NAT64, 6to4, and Teredo forms that embed one), connect only to the one address validated, do not follow redirects, and write a blocked audit row before refusing; a new or updated service must use https and a private base URL is rejected when it is saved. Existing plaintext http services still work and are logged once per service for review. This covers where a visual adapter call goes, not what the upstream does with it. What we do not solve here: the executor, A2A discovery, MCP gateway, webhook URL guard, and red-team paths do not yet block 100.64.0.0/10; other outbound calls to tenant-set URLs (SSO metadata fetch, webhook dispatch, alerting, notifications, discovery collectors, the Genesis adapter) are not covered by this check and some resolve a name twice; visual adapter calls have no response size cap or total deadline; stored URLs are re-checked on every call, not at startup. Updated 25 October 2026: none of what follows currently runs in production. The production host cannot provide the namespace confinement described below (a point-in-time check made on 12 October 2026), so custom-code adapters are refused in production; the description applies to a host where confinement is available. Previously updated 13 September 2026 and 3 September 2026. This item previously said per-destination egress stayed operator-enforced through host firewall rules until the production host granted the network privileges it needs or we built a separate egress service. Neither happened, and neither was needed. Reading the path end to end showed the branch that dropped an egress-declaring adapter into the host network namespace could never be reached by any adapter an operator can upload: the validator blocks every network-capable import before the code is stored. We deleted that branch. On the namespace-confined path every sandboxed adapter now runs with no usable network at all, whatever its manifest declares, because it runs in a private network namespace with no usable network (loopback down), not because of any syscall-level filter; the sandbox does not filter system calls. An adapter that needs an outbound call describes it instead, and Vortalis makes that call itself against the destinations the adapter declared, checking the destination by exact host match and refusing internal, loopback, and cloud-metadata addresses. That check is a single control rather than layered defence, so we name it as one. It ships switched off; turning it on is a deliberate operator decision, not a default. The fallback path used when the namespace tooling is absent still enforces no network isolation, and the sandbox as a whole remains EXPERIMENTAL pending external security review.

12

Admin multi-factor authentication is enforced by default for new tenants, and the grace period for accounts that predate the change has ended.

Every admin-tier login path, password, SSO, and SAML, is wired to a multi-factor enforcement gate. A twelve-character password floor applies with no flag at all, and a breach-password check runs by default, independent of the MFA enforcement gate, though an operator can switch it off. New tenants enforce MFA for admin, tenant admin, and security analyst accounts from their first login, no grace window; viewer accounts are not gated. Tenants that existed before this change were given a 30-day enrolment window beginning at the August 2026 cutover, after which the same enforcement applies to them. A single legacy flag remains as a fallback, relevant only to the platform's own tenant-less bootstrap account, not to any customer tenant.

13

SOC 2 Type II, ISO 27001, and third-party penetration testing are prepared for, not started.

A controls matrix, a gap analysis against the relevant criteria, and first-draft policies exist so an audit or testing engagement can start quickly, but no such engagement has begun. An operator who needs a certificate or an attestation report today does not have one from Vortalis yet. We name that here rather than let a controls matrix stand in for a completed audit.

14

One shared administrative key still exists. In production it is restricted to allow-listed addresses once an operator sets the list, and every use is audited and alerted.

The platform accepts one static administrative key in the X-Admin-Key header as super-admin, across every tenant. It has no user behind it and it does not pass the multi-factor gate in item 12, which sits on login, so super-admin access through this key is not multi-factor. It is kept as a break-glass path, not removed. In production the key is accepted only from addresses on an operator-set allow-list; the correct key from any other address is refused, and every use is written to the admin audit log before the request is processed and raised as an alert on the platform alert channels the operator has configured (with no channel configured the use is audited and logged, not alerted, and alert rules can still withhold one). A refusal is audited and alerted too, with refusal alerts limited to one per address per minute; if the database cannot record a refusal the request is still refused and the failure is only logged. The list ships empty, and while it is empty the key is still accepted from any address; the deployment reports that as degraded, so the address restriction is not in force until an operator sets the list. What we do not solve here: the allow-list limits where the key is accepted from and is not a second credential, and the address is only as trustworthy as the proxy-depth setting that resolves it; the audit row is in the admin audit log, not the per-tenant tamper-evident chain, and records that the key authenticated, not what the route then did; staging and every other non-production environment are unchanged.

We move an item off this page only when there is real engineering behind the move, never when there is real marketing behind it.

Talk to an engineer about your threat model