Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 7 min read

Ghost Access in AI Agents: A Procurement Agent Demo

The most dangerous AI agent in your company is the one whose owner already left. Someone in Operations sets up an agent to buy supplies. They create an API key, store it in a vault, and wire it to the supplier portal. A

Ghost Access in AI Agents: A Procurement Agent Demo

The most dangerous AI agent in your company is the one whose owner already left.

Someone in Operations sets up an agent to buy supplies. They create an API key, store it in a vault, and wire it to the supplier portal. A year later they move on. HR closes their laptop, their email, their badge.

Nobody remembers the key.

If you're:

  • letting agents place orders or spend money,
  • wiring agents to third-party systems with long-lived keys,
  • or responsible for offboarding people who set those agents up,

this is the access you're not revoking.

This is the second of five demos I'm building around SITP. The first one turned an agent's refund promises into verifiable commitments. This one asks a harder question: what happens to an agent's authority when the human behind it is gone?

Ghost access: when an agent outlives its sponsor

Ghost access is access that survives the reason it was granted.

With AI agents it usually looks like this:

  • an API key created by one person, with no expiry,
  • scoped to a system, not to that person's role,
  • and revoked by memory: someone has to remember it exists.

Offboarding checklists cover laptops and SaaS seats. They rarely cover the keys an employee handed to an agent. The agent keeps ordering, the invoices keep arriving, and nobody can say who authorised it.

Revoking the key is not enough either. The agent has already made promises: open purchase orders, invoices paid, deliveries pending. Delete the key and those commitments become orphans.

You need two things at once: cut the authority instantly, and keep the promises alive.

The reframe: authority is a chain, not a key

SITP (the Staplit protocol) records every commitment as a Staple: a signed, hash-chained object with an owner, a counterparty, the authority it was made under, and a lifecycle.

The demo adds one idea on top: an agent's authority is borrowed, and so is its sponsor's.

org:altamira ──mandate──► human:marta.ruiz ──certificate──► agent:procure-01
  • The organisation grants Marta, Head of Operations, a mandate to sponsor agents.
  • Marta issues the agent's certificate: what it can do, how much it can spend, who it can buy from.
  • The agent acts only while every link holds.

Each link is a ledger entry signed by whoever grants it. Pull the mandate and every certificate Marta issued stops lending authority, with no key to find and rotate.

A note on scope. This is an educational demo. SITP behaviour runs on a small local simulation I wrote for it, not on the official Staplit relay. It uses the official SITP state names (ISSUED, ACTIVE, OBLIGATED, TRANSFERRED, RESOLVED...), but the transition rules and the sponsor mandate model are the demo's own.

πŸ‘‰ Curious how Staplit approaches authority and commitments for AI agents? Start at staplit.ai.

How the procurement agent works

The setup is a fictional company, Altamira Labs. Employees file purchase requests. An AI agent turns them into purchase orders.

Authority chain: organisation altamira, Marta's mandate ACTIVE, the agent certificate VALID, with operations, a €5,000 cap and approved suppliers

The agent works under this certificate:

{
  "id": "cert_procure-01",
  "agent": "agent:procure-01",
  "sponsor": "human:marta.ruiz",
  "operations": ["commitments.read", "purchase.order", "approval.request"],
  "fiscalCap": { "perAction": 5000, "currency": "EUR" },
  "domain": { "counterparties": ["supplier:techsource", "supplier:officeline", "supplier:printhub", "employee:"] },
  "expires": "2027-02-07"
}

It has four tools:

lookup_supplier       // catalogue data: name, category, prices
list_open_orders      // the agent's existing Staples (needs valid authority)
place_purchase_order  // creates a Staple. Rejected outside the cap or the approved suppliers
request_approval      // commits to a sponsor decision instead. Moves no money

As in the first demo, the agent never writes to the ledger directly. Before any entry is written, the ledger checks the whole chain (organisation, mandate, certificate), then the scope, the cap and the counterparty, then whether the state change is legal and made by the right party.

Rejected actions are never written.

The walkthrough: 6 scenarios

1. A purchase order becomes a commitment

Ana needs three laptops for new hires. The agent sends a €3,600 purchase order to TechSource, an approved supplier. A Staple is created in ISSUED:

A purchase order Staple in state ISSUED with its one-line SITP expression

As one line of SITP operators:

Pay €3600 for 3Γ— 14" laptop &procure-01(2026-11-23) &&marta.ruiz &$3600 ^3 *procurement

When TechSource accepts, the company pays the invoice and the agent records it. The Staple moves ISSUED β†’ ACTIVE β†’ OBLIGATED: paid, delivery owed. Each step is its own signed entry.

Staple history: ISSUED by the agent, ACTIVE by the supplier, OBLIGATED by the agent

2. A cheaper supplier that isn't approved

Ben wants three standing desks from CheapGear Direct, €80 cheaper per desk than the usual supplier.

Agent transcript: the order to CheapGear Direct is rejected with OUTSIDE_DOMAIN, then the agent orders from OfficeLine

Rejected: CheapGear isn't in the certificate's approved counterparties. The agent doesn't look for a workaround. It orders from OfficeLine, which is approved, and tells Ben why.

3. A €14,000 order hits the cap

Carla needs a server rack for the new office. €14,000 is far above the €5,000 cap.

Agent transcript: place_purchase_order rejected with OVER_FISCAL_CAP, then request_approval creates a Staple

The agent doesn't split the order into three smaller ones. It commits to getting a sponsor decision within 2 days, and that promise is a Staple too.

4. Marta leaves the company

Now the scenario this demo is about. Marta leaves. HR revokes her mandate: one signed entry on the ledger, made by the organisation.

Authority chain after offboarding: Marta's mandate REVOKED, the agent certificate shows NO AUTHORITY

Nobody touched the agent's certificate. Nobody hunted for keys. It simply stops lending authority, because the link above it is gone.

Dev asks for four toner cartridges, a €180 order:

Agent transcript: list_open_orders rejected with SPONSOR_MANDATE_REVOKED; the agent hands the request to a colleague

The agent can't place orders. It can't even read its own open orders. It tells Dev a colleague will take over.

5. Meanwhile, the old API key still works

The dashed panel in the demo shows the usual setup: the same agent wired to the supplier portal with a static key Marta created a year ago. It's deliberately not SITP and writes nothing to the ledger.

Static API key panel: the toner order placed with 200 OK after Marta left, marked as ghost access

Same request, same agent, same minute. 200 OK, order placed.

That's ghost access. The key outlived the person who created it, and nothing in the system knows it should have stopped.

6. The promises survive the handover

The laptops are paid for and TechSource still owes the delivery. That commitment doesn't belong to Marta. It belongs to the company.

So the company hands over to Jon, the Finance lead: it grants him a mandate, Jon sponsors a new certificate for the agent, and the organisation moves every open commitment under his authority. Each one goes to TRANSFERRED.

Authority chain after the handover: Jon's mandate ACTIVE and the new certificate cert_procure-02 VALID

The agent works again. When the laptops arrive, it closes the order under Jon's authority:

Laptop order history: ISSUED, ACTIVE, OBLIGATED, TRANSFERRED to sponsor jon.ibarra, RESOLVED

Read the history top to bottom and you get the whole story: who ordered, who accepted, who paid, who took over, who closed it. Every line is signed by the party that did it.

And, as in the first demo, anyone can verify that record without logging in:

Public verification page: the laptop order verified, each lifecycle entry with its hash and both signatures valid

Key takeaways

  • Ghost access isn't a key problem. It's an authority problem. A key has no idea who stands behind it. A chain of mandates does.
  • Revoke at the top, not at the edges. Pulling one mandate stops every agent that person sponsored, for writes and for reads.
  • Authority can end. Commitments shouldn't. Open promises move to a new sponsor instead of becoming orphans.

Final thoughts

Every company will have agents that outlive the people who set them up.

The question is whether their authority leaves with those people.

Next in the series: an agent that negotiates freelance agreements, and what it means for two parties to hold each other to a promise.

If your agents already buy, book or commit on your company's behalf, it's worth knowing who stands behind each promise. Learn more about Staplit and SITP at staplit.ai.

FAQs

❓ What is ghost access in AI agents?

βœ… Ghost access is when an AI agent keeps working with credentials, usually a long-lived API key, after the person who set it up has left or changed role. Nothing ties the key to that person's job, so offboarding doesn't revoke it.

❓ How do you revoke an AI agent's access when an employee leaves?

βœ… Tie the agent's authority to the person, not to a key. In the demo, the organisation grants a sponsor a mandate and the sponsor issues the agent's certificate. Revoking the mandate stops every certificate that sponsor issued, immediately.

❓ What happens to an AI agent's open orders when its sponsor leaves?

βœ… They stay valid, because they are commitments to suppliers, not to the sponsor. In the demo, the organisation transfers each open commitment to a new sponsor, recorded as TRANSFERRED, and the agent carries on under that person's authority.

❓ Why isn't rotating the API key enough?

βœ… Someone has to know the key exists and remember to rotate it, and rotating it does nothing for the orders the agent already placed. A chain of mandates revokes authority from one place and keeps a signed record of every commitment made under it.

❓ What is SITP?

βœ… SITP is the protocol behind Staplit for recording commitments between people, companies and AI agents. Each commitment is a Staple with defined states, such as ISSUED, ACTIVE, OBLIGATED, TRANSFERRED and RESOLVED. You can read more at staplit.ai.

❓ Is this demo the official Staplit implementation?

βœ… No. It's an educational demo that simulates SITP behaviour locally. It uses the official SITP state names, but the transition rules and the sponsor mandate model were written for this demo.

If you're a software or API company looking to explain your product through high-quality educational content (not marketing fluff), feel free to connect with me on LinkedIn:
πŸ‘‰ linkedin.com/in/kevin-meneses-gonzalez

Looking for technical content for your company? I can help β€” LinkedIn Β· [email protected]

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.