Skip to content
Standards

Both OWASP Top 10s, mapped.

The OWASP lists cover agentic AI from two directions: the Agentic Top 10 for what attackers do to the agents themselves (ASI01 to ASI10), and the MCP Top 10 for what goes wrong around Model Context Protocol servers (MCP01 to MCP10). Alyria maps every row of both to a control that runs on the developer endpoint, recorded in one signed audit chain. OWASP names the risks; this page shows where each one is enforced.

20 / 20
risks mapped across both lists
10 ASI rows covered
concrete controls shipping today
Monitor first
then enforce when you are ready
CoveredConcrete controls, shipping today

A named control exists across Beacon, Lyra, Umbra, Constellation, or Observatory and enforces the risk in v1. Coverage is strongest when the modules run as a suite: several risks lean on more than one plane.

Pillars: APG = Agent Policy Governance (prevention) · ADR = Agent Detection & Response (detection) · Mesh = Constellation, the shared-memory plane.

Coverage map

Every risk, mapped to a named control.

One row per OWASP ASI risk: the threat in plain language, the Alyria modules and planes that address it, and an honest coverage rating. No opaque engine: every control is authored from auditable source.

ASI01Covered
ADRMesh

Agent Goal Hijack

Injected instructions hidden in a web page, tool output, or retrieved document quietly redirect an agent away from the task its operator actually gave it.

How Alyria addresses it

Beacon Plane C runs a content-safety scan over every tool/MCP response and model input/output, reusing Constellation's shipping prompt-injection layer, so injected instructions are caught before they reach the agent. Tier-3 intent classification and Tier-2 trajectory analysis are the hardening path, staged monitor-first.

Beacon Plane CConstellation content-safetyTier-2 / Tier-3 detection
ASI02Covered
APG

Tool Misuse & Exploitation

A legitimate tool is invoked in a harmful way, or tools are chained, to reach data or actions the agent was never meant to touch.

How Alyria addresses it

The core wedge: Beacon Plane A mediates every tool call and gates it against Lyra capabilities and Tier-1 policy. Anything ambiguous is escalated to an Observatory JIT approval instead of silently running.

Beacon Plane ALyra capabilitiesObservatory JIT approvals
ASI03Covered
APG

Identity & Privilege Abuse

An agent runs with more privilege than its task requires, or reuses a standing credential to reach systems well beyond its remit.

How Alyria addresses it

Identity is resolved from your IdP through Constellation and enforced with relationship-based access control, and Lyra's capability-brokering makes least-privilege the default. Umbra's short-lived secret leases retire standing credentials entirely.

Constellation identityLyra capabilitiesUmbra leases
ASI04Covered
APGADR

Agentic Supply-Chain

A poisoned, down-level, or malicious MCP server, tool, or package the agent pulls in becomes the way into your environment.

How Alyria addresses it

Beacon inventories installed AI tooling and MCP servers and flags down-level or malicious ones, and can refuse them at launch once you turn enforcement on; all MCP traffic flows through the Beacon gateway; Lyra ships signed, versioned policy bundles; and code-integrity allow-listing constrains what may run.

Beacon inventory + gatewayLyra signed bundlesCode-integrity allow-listing
ASI05Covered
ADRAPG

Unexpected Code Execution

The agent sidesteps the mediated tool path by spawning a shell, a detached job, or an out-of-band process to run code directly.

How Alyria addresses it

Beacon observes process launches and agent activity from user space (no kernel driver), flags out-of-band processes, and Lyra capability limits bound what any launched process may do.

Beacon runtime observation (user-space)Lyra capability limits
ASI06Covered
MeshADR

Memory & Context Poisoning

Malicious content is planted in an agent's long-term memory or a shared RAG corpus so it resurfaces later and quietly steers behavior.

How Alyria addresses it

Constellation scopes memory and documents behind one ACL and runs content-safety on every ingest, so poisoned context never enters shared memory in the first place; Beacon Plane C additionally scans retrieved content at recall time.

Constellation scoped memoryContent-safety on ingestBeacon Plane C
ASI07Covered
APG

Insecure Inter-Agent Comms

Agents coordinate over channels an attacker can spoof, intercept, or read, turning agent-to-agent protocols into an exfiltration path.

How Alyria addresses it

Umbra performs A2A key exchange with signed agent identities over mTLS, and seals shared secrets to the receiving agent so the broker only moves ciphertext.

Beacon Plane CSigned identities / mTLSUmbra A2A
ASI08Covered
APGADR

Cascading Failures

A single compromised or malfunctioning agent triggers a runaway chain (retries, fan-out, or a rate spike) that cascades across the mesh.

How Alyria addresses it

Lyra enforces capability budgets with rate and circuit limits, Beacon's Tier-2 trajectory analysis catches the escalation early, and a disposition kill-switch can halt an agent outright, all staged monitor-first before anything enforces.

Lyra capability budgetsTier-2 trajectoryDisposition kill-switch
ASI09Covered
APG

Human-Agent Trust Exploitation

An agent produces a polished, confident justification for a risky action, and a human approves on the strength of the wording rather than the evidence.

How Alyria addresses it

Observatory's policy-driven JIT approvals put independent risk evidence, a rationale, and a score in front of the human approver, not the agent's own self-justification, and every decision is written to the signed audit chain.

Observatory JIT approvalsHuman-approver workflowLyra policy

The strength here depends on the approval UX surfacing independent evidence: the principle the whole approver workflow is built around.

ASI10Covered
ADR

Rogue Agents

An agent goes off-mission (self-directing, concealing what it's doing, or pursuing goals no one assigned) and works to avoid detection.

How Alyria addresses it

Beacon layers Tier-3 behavioral anomaly detection and Tier-2 trajectory analysis with Plane B user-space runtime correlation and a kill-switch; posture flags unknown agents, and can refuse them at launch once you turn enforcement on; and Umbra's zero standing privilege bounds the blast radius when something does slip through.

Tier-2 / Tier-3 detectionBeacon Plane BPostureUmbra zero standing privilege
The MCP Top 10

The OWASP MCP Top 10, with a control per risk on the developer endpoint.

The OWASP MCP Top 10is OWASP's ranked list of the ten most significant risk categories for systems built on the Model Context Protocol, published as MCP01 through MCP10. On a developer laptop, most of the ten share one root cause: a client config quietly wires an unpinned server into a session that runs with the developer's own credentials, and that laptop is where enforcement is supposed to happen. The table pairs each risk with the control that closes it.

RiskWhat goes wrongThe control that covers it
MCP01Token Mismanagement & Secret ExposureHard-coded credentials, long-lived tokens, and secrets stored in model memory or protocol logs. Prompt injection, a compromised context, or a debug trace can hand them to an attacker.Keep tokens out of agent config, and never leave an agent a standing credential. Umbra issues short-lived leases that Alyria Beacon injects at the moment of use and discards afterward. Beacon flags plaintext credentials already sitting in mcpServers env blocks across the fleet.
MCP02Privilege Escalation via Scope CreepLoosely defined or temporary permissions expand over time: an agent that started with read access ends up able to modify repositories, control systems, or exfiltrate data.Grant a capability, not a standing grant. Lyra policy is capability-brokered: agent X may call tool Y against resource Z for this task, and nothing more. OAuth 2.1 on remote servers, as the MCP spec directs, covers the transport; the action-level scope is still enforced where the call is made.
MCP03Tool PoisoningMalicious, misleading, or biased instructions hidden in tool descriptions, schemas, or results steer the model without anyone noticing.Pin the version you vetted and inspect what the server says before the agent acts on it. Beacon inventories every configured MCP server and flags unpinned entries; a content-safety scan runs over tool responses before they reach the model.
MCP04Software Supply Chain Attacks & Dependency TamperingA compromised package, backdoored server, or poisoned dependency alters agent behavior or introduces an execution-level backdoor.Pin exact versions and verify provenance before install. An unqualified entry resolves whatever copy is in the cache at launch, so two machines can run different code from the same config line. Beacon tracks the version each endpoint actually runs and can refuse an off-list server at launch once enforcement is on.
MCP05Command Injection & ExecutionAn agent constructs and executes shell commands, scripts, or code from untrusted input without validation or sanitization.Deny the call before it runs, and bound what any spawned process can do. Codex's sandbox and approval policy and Claude Code's sandboxing and PreToolUse hooks are the vendors' own controls; user-space runtime observation covers processes that bypass the mediated path.
MCP06Prompt Injection via Contextual PayloadsInstructions hidden in pages, issues, or tool output redirect the agent's own reasoning. The model is the interpreter and text is the payload.Treat everything the agent reads as untrusted, and write the follow-through down. Content-safety scans run on tool responses and shared-memory recall, and sequence policy closes the second step: if the session has read a flagged payload, block network egress.
MCP07Insufficient Authentication & AuthorizationMCP servers, tools, or agents fail to verify identities or enforce access controls, so callers reach data and actions they were never entitled to.Bind the agent to an identity your IdP knows and enforce per-identity grants in policy. HTTP servers can require OAuth 2.1 as the MCP spec directs; a stdio server runs as the local user with no identity boundary at all, so the grant that matters is the one evaluated at the call.
MCP08Lack of Audit and TelemetryLimited telemetry from MCP servers and agents impedes investigation and incident response; nobody can reconstruct what an agent actually did.Record every tool call, the policy decision attached to it, and the identity that made it, in one signed, hash-chained chain, then route the signal into the SIEM over OpenTelemetry so existing detections see agent activity in the same pipeline as everything else.
MCP09Shadow MCP ServersUnapproved MCP deployments operating outside security governance, often with default credentials, permissive configuration, or unsecured APIs.Keep a live inventory of the config each client holds, including stdio servers that never cross the network, diff it against the approved list, and enforce the allowlist at launch. The client-by-client config paths are in how to find every MCP server on your laptops, and the Agent Exposure Report inventories a pilot cohort first.
MCP10Context Injection & Over-SharingShared, persistent, or insufficiently scoped context windows let what one task, user, or agent saw leak into another session.Scope context per division and role with one ACL enforced on both reads and writes, run content-safety on ingest and recall, and scan outbound payloads for data that should not leave the session. Constellation is the shared-memory plane doing this today.

Vendor controls carry part of each row

Deploy the native controls first, because they exist today. Claude Code delivers managed settings, managed MCP configuration, and PreToolUse hooks as one policy file. Cursor exposes hooks with a beforeMCPExecution event. Codex relies on its sandbox and approval policy. The Copilot CLI runs repository hooks. Each is per client and per machine, which is the structural gap: four clients means four policies to author, four places to check, and the coverage gap lands wherever the least configured client sits. The client allowlist specifics are in the Cursor, Codex and GitHub Copilot enterprise posts. The Claude Code post documents that gap, and the endpoint vs gateway guide covers what a gateway adds and misses.

One concrete setup example

A PreToolUse hook in Claude Code's managed settings denies every MCP tool call whose gate script does not answer, and onFailure: "block" makes a broken gate fail closed rather than open:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__.*",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/mcp-gate.sh",
            "onFailure": "block"
          }
        ]
      }
    ]
  }
}

The file ships to /Library/Application Support/ClaudeCode/ on macOS, /etc/claude-code/ on Linux and WSL, and C:\Program Files\ClaudeCode\ on Windows, in the same directory as the permissions denies. In Cursor, the equivalent event is beforeMCPExecution with a deny set in ~/.cursor/hooks.json.

The mapping is per endpoint rather than per client: the same inventory, one policy file, and one audit chain covering Claude Code, Cursor, Codex, and Copilot on the same machine. Start read-only with the Agent Exposure Report to see what this mapping would have done on your own fleet this week.

Standards anchor

OWASP ASI for what attackers do. NIST and ISO for how you govern it.

The same signed audit chain that proves an ASI05 code-execution block to a red team is the evidence that satisfies a 42001 audit: one source of truth, so the adversarial story and the compliance story can never drift.

NIST AI RMF

Map / Measure / Manage / Govern: the risk-management spine US enterprises align to.

ISO/IEC 42001

The AI management-system standard your auditors and procurement teams ask for by number.

EU AI Act

Risk-tiered obligations for AI systems: the regulatory anchor for governance buyers.

One chain, both audiences. Alyria maps to the standards without a second system to reconcile: see how the crypto, audit chain, and enforcement fit together on the security model.

Try it with Alyria

Run the mapping against your own fleet.

Install Alyria Beacon read-only on one developer machine, give it about 30 minutes, and compare its MCP server inventory with the table above: unpinned servers land under MCP04, plaintext tokens in config under MCP01, and off-list entries under MCP09, each with the risk id attached. Start free at alyria.ai and read the Beacon docs for the three enforcement planes.

See the coverage map against your estate.

Walk ASI01 through ASI10 with our team on your own agents and tooling, or read how verifiable key custody and one tamper-evident audit chain hold it all together.

Free. Read-only. Remove it with one command.