Authority for a fleet of agents.

KIFF lets the owner decide what each AI agent may do, and change it in seconds, without touching the agent.

Meet Pete. His agents work.

Pete builds agents for other companies. They read the case, check the order and propose the right refund. His clients are happy.

Each agent gets a key to the tools it needs. A key lets it reach the refund tool. It cannot say how much that agent may spend today.

Success brings twenty agents. And a bottleneck.

Then Pete meets Anne.

Anne runs operations with her own fleet of agents. She doesn't write limits into them. She issues each one a card.

The card says which actions, in which states, and how much. It lives outside the agent. To change what an agent may do, Anne changes the card.

A key reaches the tool. A card says how far.

	Key, limits in code	KIFF Card
Which actions	Anything the tool allows	Named actions only
How much	A counter in each agent	A ceiling, one balance per card
Who changes it	Pete, with a deploy	The owner, instantly

Incidents: stop three agents, not twenty.

Refunds spike on three agents at 2 a.m. The client revokes their three cards. The other seventeen keep working. Nobody calls Pete.

Busy weeks: more room, no release.

Black Friday: the client raises eight cards from €5,000 to €20,000 a day, and back on Monday. Same agents, same code, every change on the record.

New models: ship on a narrower card.

Five agents move to a new model. They start on narrower cards and widen when their statements look right. The other fifteen never change.

Anyone can write a limit.

Nobody wants every deployment to own the lifecycle of authority: who holds it, what is left, who changed it, how to take it back.

Twenty agents, twenty balances	Each agent draws on its own card. One agent can never spend another's authority.
Two runs of one agent spend at once	Draws on that agent's card are locked. The second is refused if the first leaves too little.
A request is retried	Counted once.
The balance cannot be read	Refused, never treated as zero.

Proof that this is infrastructure worth centralizing, not the reason to buy it.

Pete now builds every agent with a card.

Pete doesn't adopt KIFF because he can't code a limit. He adopts it because authority should no longer belong to each agent implementation.

Why now: cheap agents create fleets.

Agents are becoming cheap to build and cheap to run. That creates fleets. Fleets turn authority from application logic into infrastructure.

Traction: shipped and verified. Not yet sold.

Shipped	Hosted decision runtime, cards, card inventory and statements, signed receipts. MIT framework.
Verified	A Refund Card on a real production run.
To prove	Paying customers running cards across real fleets.

Business: builders carry KIFF to clients.

Distribution hypothesis: builders bring the authority layer with the agents they ship.

The framework is open source, so a builder can adopt it without a contract. Each client pays for Cloud, the recurring layer: a platform fee plus usage. Adoption starts founder-led: observe one action on real traffic, then issue the cards.

A hypothesis to prove, not a proven channel.

The real competitor: building it yourself.

KIFF makes authority a first-class object outside the agent.

Independently owned	By the business, not by the code that uses it.
Changeable without a redeploy	Raised, narrowed or revoked while the agent runs.
Stateful and consumable	One balance, drawn down by every authorization.
Versioned and auditable	Every change attributed; every decision on a signed receipt.

Payment-focused agent spend controls bound money leaving a wallet. KIFF bounds any business action, checked against live state.

Team: Gabriel, founder.

Gabriel is a serial entrepreneur and builder. The investor is backing him.

Proof of velocity: the framework, the hosted runtime and the cards were shipped by Gabriel working with two AI engineering agents, running on Claude and GPT: github.com/gabosarmiento and github.com/agentgabo.

What the money builds.

Later, enabled by the authority layer: judgment for held exceptions by fast decision models such as TypeSafe's Jev, always inside the card, with low confidence still going to a person.

Planned, not built. Today, held proposals go to a person, and revocation is one action per card.

Where KIFF goes: from a card to the standard stack.

1. Month 0The card works.Verified on a production run.
2. Month 6Builders trust it in production.First builders running KIFF for paying clients.
3. Month 12Builders reuse it across customers.Builders running KIFF for two or more clients.
4. Month 18 to 24Part of the standard agent stack.New agents ship with a card by default.

The ask: $8M.

1. Builders adopt
2. Some reuse KIFF across clients
3. Customers expand cards across their fleets
4. ARR follows