Lumen: Govern Every Agent. Make Every Application Agent-Ready.

Agentic AI is coming to your enterprise either way. Lumen is how it arrives governed: discover every agent, decide what it may reach, generate precise MCP servers and A2A agents from the APIs you already have, and never leave a standing credential behind. In your VPC, on your existing network.

Lumen: AI agents governed on the way to enterprise applications AI agents flow through the Lumen AI decision plane, Lumen A2A Gateway, Lumen POET, and POET Credential Broker, then reach enterprise applications and data. One untrusted agent is blocked at the plane.
AI AGENTSAI DECISION PLANELumen A2A GatewayLumen POETPOET Credential BrokerEnterprise Applications, Data, and MCP Servers

Who This Page Is For

One Platform, Four Reader Questions

CISO / CSO

Can I put zero trust around AI agents?

Yes. PeerGroups pair enterprise applications with only the agents approved to reach them, intent is checked on every call, and everything is logged.

CIO

Can we adopt agents without re-architecture?

Yes. Lumen installs in your VPC, rides your existing network layer over industry-standard ICAP, and never touches the applications behind the agents.

Chief AI Officer

Can I scale agents with governance built in?

Yes. Discovery, risk scores, PeerGroups, and just-in-time credentials mean the fleet grows without the risk growing with it.

Application Owner

How do I make my application agent-ready?

Hand POET your OpenAPI, Swagger, or RAML spec. It generates a precise MCP server and A2A agent scoped to exactly the operations you choose. No code.

The Challenge

The Agent Layer Is the New Trust Boundary

AI has moved from chat to action. Agents invoke tools, call APIs, and make decisions at machine speed, over A2A, MCP, tool calls, and delegated access. None of it sits inside the identity boundaries your security model was built around.

Shadow AI is the new shadow IT. Most agents run inside frameworks like LangChain, CrewAI, and n8n, authenticating with a human's OAuth grant or a shared service account, invisible to your identity provider. And even agents with first-class identities can drift: valid credentials, changing behavior. Governing this layer at runtime is the job Lumen was built for.

The new trust boundary: the A2A and MCP agent communication layer AI agents above and enterprise systems below communicate through a middle layer carrying A2A, MCP, tool calls, and delegated access. Side brackets show user and device controls covering the agents' side and application controls covering the systems' side, while the communication layer between them is marked not covered: the new trust boundary. covered covered AI AGENTSA2AMCPtool callsdelegated access NEW TRUST BOUNDARY ENTERPRISE SYSTEMS USER & DEVICE CONTROLS APPLICATION CONTROLS NOT COVERED

THE PLATFORM

Three Products, One Governed Path

Lumen A2A Gateway

Discovers AI agents and the enterprise resources they call, with risk scores. Pairs each enterprise application with only its approved agents through PeerGroups, maps and checks the intent of every request, and logs a forensic trail.

Lumen POET

Generates precise MCP servers and A2A agents from the API specifications you already have: OpenAPI, Swagger, RAML. No code, and only the operations the owner chooses become agent-callable.

POET Credential Broker

The PDP and PEP for last-mile access, with an integrated MCP layer for policy management. Decides by role, user, and group, and issues just-in-time, workload-bound, time-bound tokens. Standing tokens stay in your PAM vault.

The Playbook

If You Want to Do This, Here Is How

Five plays, in the order most enterprises run them. Each one stands alone; together they take you from unknown agents to a governed fleet.

Lumen A2A Gateway

If You Want to See Every AI Agent and What It Touches

For the CISO and the CIO
AI agent discovery and risk scoring with the Lumen A2A Gateway Undiscovered AI agents and enterprise resources are discovered by the Lumen A2A Gateway and ranked with risk scores; the IT admin assigns the discovered agents and resources into the appropriate PeerGroups with policies.

The play: put the Lumen A2A Gateway inline. It discovers the AI agents in your environment and the enterprise resources they call, then risk-scores every finding. Your admins work a ranked queue, not a blank map.

What you get: shadow AI becomes a governed inventory in days. Each discovered resource and its calling agents move straight into a PeerGroup with policies attached, so discovery flows into enforcement in the same motion.

Lumen A2A Gateway

If You Want Only Approved Agents Near Your Enterprise Applications

For the CISO
The play: PeerGroup your estate. Pair each enterprise application with the agents approved to talk to it, default-deny for the rest. The gateway also maps the intent of every request and checks it before the call proceeds.

What you get: Exposure to unapproved and shadow agents drops to zero by default, every approved call is intent-verified, and every interaction is logged with the agent, the access, and the actions taken. Evidence your auditors can actually use.

Lumen POET

If You Want Your Applications to Be Agent-Ready

For the Application Owner
Lumen POET generates precise MCP servers and A2A agents from your existing APIs An existing API specification, OpenAPI, Swagger, or RAML, goes into Lumen POET, which generates a precise MCP server and an A2A agent scoped to exactly the operations the application owner chooses, with no code.

The play: point Lumen POET at the API specification you already have. OpenAPI, Swagger, or RAML goes in; a precise MCP server and an A2A agent come out. No code, and only the operations you choose become agent-callable. It works alongside the API infrastructure you run today, including Kong, Apigee, AWS API Gateway, and MuleSoft.

What you get: your application joins the agent economy in days without being touched. The scope is yours to define, so being agent-ready never means being agent-exposed.

POET Credential Broker

If You Want Standing Credentials Out of Every Agent

For the CISO and the Chief AI Officer
The play: move last-mile access decisions into the POET Credential Broker: PDP and PEP in one place, with an integrated MCP layer for policy management. Owners define the scope scheme; the broker decides by role, user, and group and issues short-lived, workload-bound, time-bound tokens at the target. Standing tokens stay in your PAM vault.

What you get: least privilege by default, credentials that expire with the task, and one policy point that keeps audit scope flat as the fleet grows. Workload identity and access management with zero standing privileges.

Deployment

If You Want All of This Without Re-Architecting Anything

For the CIO
Lumen deployment: inline governance in your VPC, no re-architecture AI agents pass through your existing network layer, which steers traffic over industry-standard ICAP RFC 3507 to the Lumen A2A Gateway running in your VPC. POET-built MCP servers and A2A agents front your enterprise applications. The POET Credential Broker exchanges just-in-time tokens against your PAM vault. Works with leading networking and firewall technologies.

The play: install with Helm or Terraform in your VPC. Your existing network layer steers agent traffic to the gateway over ICAP (RFC 3507), the same industry-standard offload method networks already use for DLP, so Lumen works with the leading networking and firewall technologies. Where ICAP is not in the path, agents reach resources through proxied URLs.

What you get: runtime governance dropped into the environment you already run. Applications untouched, execution inside your VPC, and no proprietary integration to maintain.

The Value

Inline and Realtime, on the Network You Already Run

Most of the market watches agent risk from the outside: inventories, posture scores, after-the-fact detections.

Lumen sits inside the conversation. Here is what that means in practice, and what each piece is worth.

Inline inspection of A2A and agent-to-MCP traffic

What it is: Lumen rides your existing network infrastructure. Firewalls, proxies, and SASE steer agent traffic to the gateway over industry-standard ICAP (RFC 3507), the same offload path networks already use for DLP; where ICAP is not in the path, agents reach resources through proxied URLs. Every agent-to-agent and agent-to-MCP call passes through Lumen on its way to the resource.

Why it matters: you cannot govern traffic you only read about in logs. Inline means the call is seen before it lands, not reconstructed after. And because the steering comes from infrastructure you already operate, the deployment cost of getting inline is close to zero.

Realtime PDP and PEP, at the moment of action

What it is: every call gets a policy decision (PDP) and enforcement of that decision (PEP) in the same flow, in milliseconds, with a verdict written to the log: agent, user, policy, allow or deny.

Why it matters: posture tools tell you an agent has too much access; realtime enforcement stops the call that would exercise it. The difference shows up directly in cost: incidents prevented at the gateway are incidents your team never investigates, contains, or discloses.

PeerGroups: microsegmentation for the agent layer

What it is: each enterprise application is paired with only the agents approved to talk to it, default-deny for everything else. Discovery feeds the groups; risk scores set the priority; your existing security groups can map straight in.

Why it matters: blast radius collapses. A compromised or drifting agent can reach exactly one PeerGroup's resources, not the estate. You get zero trust segmentation for agents without redesigning a single VLAN, and audit scope shrinks to the groups an auditor actually asks about.

Intent checking: the control identity cannot give you

What it is: the gateway maps the intent of each request and checks it before the call proceeds. Not just who the agent is, but what this specific call is trying to do, against what the interaction legitimately needs.

Why it matters: the hard failures in agentic AI are valid-credential failures. An agent with a perfect identity can still drift, over-reach, or be manipulated into calls it should never make. Identity passes those calls; intent checking catches them. This is where autonomy stays useful without becoming exposure.

Scoped, workload-bound access through the POET Credential Broker

What it is: the broker holds the PDP and PEP for last-mile access, with an integrated MCP layer for policy management. It decides by role, user, and group, and issues just-in-time tokens bound to a specific workload and a specific time window. Standing tokens stay in your PAM vault.

Why it matters: a stolen token is useless outside its workload and expires with its task. Zero standing privileges stops being a program goal and becomes the default mechanics. Credential rotation toil drops, and the fleet can grow without the credential attack surface growing with it.

Business value

Agent adoption stops waiting on security exceptions. Applications become agent-ready in days, and the answer to new agent requests changes from "not yet" to "which PeerGroup."

Security value

Default-deny reach, intent-verified calls, and no standing credentials in agents. The three failure modes of agentic AI, closed at one control point, with forensic evidence for every verdict.

ROI value

Prevented calls replace investigated incidents. Discovery replaces months of manual cataloging. One policy point replaces per-application credential plumbing, and audits pull from one log.

No forklift

Your network steers, your vault keeps the secrets, your security groups define the policy context, and your applications are never re-architected. Lumen adds the layer; it replaces nothing.

Outcomes

What Changes When Lumen Is In

• Shadow AI becomes a governed, risk-ranked inventory in days, not quarters.
• Enterprise applications are default-deny to every agent you have not approved.
• Applications become agent-ready from the specs you already have, without new code.
• Standing machine credentials are retired; access is just-in-time and expires with the task.
• Every agent interaction leaves audit evidence: agent, user, policy, verdict.

FAQ

Questions Teams Ask Before Deploying

Do our applications need to change to become agent-ready?

No. Lumen POET reads the API specification you already have, OpenAPI, Swagger, or RAML, and generates a precise MCP server and A2A agent from it. The application itself is not touched, and only the operations you choose become agent-callable.

How does agent traffic reach the Lumen A2A Gateway?

Over industry-standard ICAP (RFC 3507) from your existing network layer, or through proxied URLs. ICAP is the same offload method networks already use for DLP, so Lumen works with the leading networking and firewall technologies without proprietary integration.

Where does Lumen run?

In your VPC, installed with Helm or Terraform. All execution stays inside your environment; nothing is sent out for processing.

Is this a non-human identity or workload IAM product?

Lumen governs the runtime, which is where NHI risk actually materializes. The A2A Gateway controls which agents may reach which resources; the POET Credential Broker holds the PDP and PEP and replaces standing machine credentials with just-in-time, workload-bound, time-bound tokens. Standing tokens stay in your PAM vault.

How is a POET-generated agent kept precise?

The application owner defines the scope-of-access scheme: which operations, for which roles, users, and groups. The generated MCP server and A2A agent expose exactly that and nothing else, and the broker enforces it on every call.

What do we see for audit and compliance?

Every interaction is logged with the agent identity, the user it acts for, the policy applied, and the verdict. The trail maps to the evidence your auditors already ask for.