Authorize per action,
not per identity.
Modern systems give durable authority to actors that are anything but durable. VantEdgeMesh breaks that weld: every operation is permitted on its own, and nothing is left standing afterward.
Request a pilotSee the architecture
The pattern behind the breaches
A stolen token. A leaked integration credential. An agent that was told not to delete, and did. Different incidents, one cause: something that should have been temporary was holding standing authority.
Snowflake customers, 2024
Stolen credentials stayed valid for long periods, some exposed years earlier.
Salesloft Drift, 2025
Compromised integration tokens opened connected customer systems.
Replit, 2025
A coding agent deleted a production database despite instructions not to change anything.
Filters and monitoring try to guess what an agent might do. They cannot take away authority the agent already holds.
A different primitive
Everyone else asks
VantEdgeMesh asks
The second question has no account in it, and no organization. That one change is why systems owned by different parties can finally work together.
Four things that are not the same thing
No standing data. No standing authority.
Let systems act without letting them keep the keys.
VantEdgeMesh sits between whoever asks for work and the system that does it. Requesters get a result. They never get the authority behind it.
What it does
Authorizes one operation
Each approval covers a single action, is consumed when used, and cannot be replayed.
Keeps credentials away from requesters
Destination credentials stay behind controlled connections. Agents and apps do not hold them.
Works for people and software
An employee, a contractor, an application and an AI agent are protected by the same model.
Connects what you already run
Existing systems stay in place and keep their own rules. VantEdgeMesh controls how they are reached.
Crosses organizational lines
Independently owned systems can cooperate without any party's identity living inside another's.
Ends cleanly
Work runs in a session. When it ends, it is torn down and a record is sent to you. Nothing waits around.
What it replaces
- Credentials baked into agents and automation
- Broad service accounts
- Long-lived integration tokens
- One identity context per system, per vendor, per agent
Priced by capacity, not by identity
What is sold is working capacity for a period of time. Nothing in the model requires a named, durable account behind it.
We don't hold what we don't need
We don't want your data and we don't want the responsibility of holding it. Sessions are yours; the record of what happened goes to you at teardown, and we keep no copy. For regulated teams that means less to protect, less to erase and less to explain.
Authority that expires with the operation.
The decision to allow an action is made outside the requester, by the system that will carry it out. An agent's reasoning is never the final word.
What changes
| Failure mode | With standing authority | With per-operation authority |
|---|---|---|
| Requester compromised | Attacker inherits everything the identity could do | Attacker holds no reusable permission |
| Agent ignores instructions | Destructive action succeeds if the credential allows it | The destination refuses what was never permitted |
| Integration token stolen | Usable until someone notices and revokes | Requesters never held the underlying credential |
| Sprawl | Every agent, every system, another credential | Credentials stay in a few controlled connections |
| Erasure and audit | Durable identities and memory to track down | Session-scoped, delivered to you at teardown |
How we describe our claims
Four levels, used honestly: prevented (a tested control stops the mechanism), mitigated (a tested control reduces the consequence), potentially preventable (the architecture has a relevant control, not yet demonstrated), and not addressed. We map documented incidents against those levels. We do not claim we would have stopped every breach.
Where the edges are
- A permission system cannot stop an actor that can bypass it entirely. Containment and the integrity of the execution environment matter as much as the approval itself.
- Two individually permitted operations can combine into a leak, such as reading private data and then publishing it. That needs information-flow controls, an area we are actively working on.
- Complete compromise of a destination host can defeat local controls.
- Accountless is not anonymous. Network metadata and payment relationships can still expose information.
Break the weld.
To do a thing on a computer you must have an account. The account is an identity, the identity carries authority, and the authority persists between uses. Four separate concerns, fused into one object.
There was never a technical reason for that fusion. It happened because the first systems needed all four at once.
Everything downstream of the weld
Tenant, organization, session, device and region boundaries all exist to contain something durable. When nothing durable is held, they stop being load-bearing.
The question changes
At every boundary today
Here
Why that unlocks cross-organization work
Authority belongs to an account, accounts belong to an organization, so authority cannot cross an organizational line without one party's identity sitting inside the other's system. No organization accepts that. Remove the account and the chain never starts. That, not an unbuilt feature, is why incumbents cannot simply add it.
Identity was the wrong primitive for machines
A person is continuous and accountable over time, so an account is a workable stand-in. An agent is created for a task, may be one of thousands, and has no continuity. Giving it an identity means inventing something durable to represent something that isn't, then defending that invention forever.
What replaces the account
Scope, duration, revocation, audit, billing and isolation all land on the session. A session ends and a new one begins; it never moves mid-flight, because a moved session would exist as data at rest and quietly re-weld what was broken. Anything that makes a session behave like an account (durable, re-presentable, transferable, waiting between uses) is a bug in the design.
Status
| Stage | Purpose |
|---|---|
| Alpha (now) | Proof of the model: single-use operation authorization, destination-side approval, enforced prohibitions and credential separation, demonstrated end to end against a real external system. |
| Beta | Adversarial testing, more systems, reliability under real conditions. |
| Version 1 | A dependable enterprise product with defined threat models, administration and support. |
VantEdgeMesh is closed source. We are glad to walk qualified engineers through the design.
Let's talk.
If you are deploying agents, or connecting systems that don't share an owner, we should compare notes.
Request a pilotArchitecture walkthrough
Investors
Agents are becoming operational and governance is becoming mandatory, while the identity model underneath was built for people. The missing layer is authorization of the action itself. If you work on infrastructure and distributed systems, we would like to hear from you.