SaaCIP: The SaaC Interoperability Protocol, and Why the Agentic Economy Needs One
Protocols already carry the calls between agents and tools. Nothing I could find carries the hire: the terms, the limits, the evidence and the track record. So I wrote those rules down, and gave them a name.
Hiring AI takes more than a protocol for calls. SaaCIP, the SaaC Interoperability Protocol, sets out shared rules for the hire itself: what was agreed, who is in charge, what evidence is left and what the track record says. With them, any capability can be hired anywhere and answer for its work.
- A hire is more than a call. MCP, A2A and payment protocols carry calls and money. A hire also needs terms, limits, a person in charge, evidence and an account at the end.
- Shared rules make a market. Like the shipping container: when the rules are standard, providers integrate once, customers can switch, and track records can be compared.
- Six steps, every hire. Agree the terms, start, report the work, stay in control, leave evidence and learn, then give a statement.
- Open for comment. Version 0.1 has one core and a first profile, Resident SaaC, for capabilities that live inside the customer’s own environment.
Bottom line. The Agentic Economy needs more than good AI. It needs shared rules for hiring it.
Below: the full article, for technical teams ↓"A market needs shared rules before it needs more products."
Start here
This is Part 3 of the SaaC series. Part 1 argued that software stops being sold as seats and starts being hired as capabilities. Part 2 took a capability apart into its manifest, surface, kernel and guardrails, and looked at the protocols that carry its calls.
This part adds one thing those two parts left open: a shared set of rules for the hire itself. I call it SaaCIP, the SaaC Interoperability Protocol. The full specification, version 0.1, is published here as a draft for comment.
Update, 6 November 2026: version 0.2 is now the current specification at /saacip/, with the Resident and Hosted profiles, a page of questions in plain words, working examples you can run and a draft registry of capabilities. Version 0.1, which this article describes, stays published unchanged at /saacip/0.1/core/; what readers said about it, and what 0.2 changed, is its own page.
If the terms capability, manifest, hire-token, receipt and registry are new to you, the Agentic Economy explainer covers them in five minutes.
Why I had to define it
I did not set out to write a protocol. I set out to build something.
For this series I built an AI capability that does not run in a provider's cloud. It is deployed inside the customer's own environment, reads their logs where they are, raises help desk tickets when something goes wrong, and can be hired for one task, for a fixed term or permanently. I call that kind of capability a Resident SaaC.
Building it, I kept hitting the same questions, and none of them were about how to call a tool:
- How does the customer see, before anything happens, exactly what this capability may read and do?
- How does it report its work so that a retry never creates a duplicate ticket?
- How does a person approve an action, and how does the capability find out?
- What evidence does it leave, and how can the customer check that nobody changed it?
- How do people's judgements of its work flow back into it?
- How does the hire end, and what account does the capability give of itself?
I looked for a standard that answered these questions. The protocols that exist are good at what they were built for, and none of them, as I read them, set out to cover the hire as a whole. So every answer I wrote was a custom answer, for one capability and one customer. That is the moment you know you need a protocol: when the same questions come back, and every answer you give is a private one.
The gap: protocols for calls, not for hires
Part 2 made a point that matters here: protocols are the pipes. The agent ecosystem now has good pipes.
| Protocol | What it carries | What it leaves to others |
|---|---|---|
| MCP (Model Context Protocol) | An agent calling tools in a session | Terms of a hire, approvals over time, evidence, track record |
| A2A (Agent2Agent) | Agents talking to other agents and handing over tasks | The same |
| Payment protocols, such as AP2, ACP and x402 | Paying for something an agent bought | What was agreed, what was done, and whether it was any good |
This is not a criticism of any of them. A pipe should be a pipe. But a hire is more than a call. A call lasts milliseconds. A hire can last a minute, a fortnight or years. It has terms, limits, a person in charge, a record of what happened, and a judgement at the end.
In the world of people, nobody would hire a contractor on a phone line alone. The phone carries the conversation; the contract, the timesheet and the reference letter carry the hire. SaaCIP is the contract, the timesheet and the reference letter for hired software.
Pipes carry the calls. SaaCIP carries the hire.
The hireSaaCIP, the SaaC Interoperability Protocol
What every hire has in common, whoever provides the capability and however it runs. Lasts as long as the hire: a minute, a fortnight or years.
The callsExisting agent protocols
Each one good at its own job. Lasts as long as the call.
The networkHTTPS and identity
Encrypted transport, and credentials that work only for the hirer they were issued to.
SaaCIP does not replace the protocols that carry calls. It adds the rules for the hire around them.
Why the Agentic Economy depends on it
The Agentic Economy rests on three units: the capability is the unit of trade, the signed receipt is the unit of settlement, and the registry is the market. Each of the three only works if everyone means the same thing by it.
Think of the shipping container. Ships, cranes and trucks existed long before it. What changed world trade was agreeing on the size of the box. Once the box was standard, any ship could carry any cargo to any port, and the cost of moving goods fell sharply. The container did not make ships faster. It made them interchangeable.
Hiring software needs the same kind of agreement. Without shared rules:
- Every hire is a custom integration. A provider builds one way of working for each customer, and a customer learns a new one for each provider.
- Customers are locked in. Switching provider means rebuilding the controls, the reports and the audit trail.
- Track records cannot be compared. If every provider counts differently, a registry cannot rank them fairly, and a strong performer cannot prove it.
- Trust does not travel. An auditor, an insurer or a regulator has to learn every provider's evidence from scratch.
With shared rules, the opposite happens. A hirer can switch providers without rebuilding anything. A provider integrates once and can be hired anywhere. A registry compares like with like. An auditor reads one kind of receipt. That is what interoperability buys: not a feature, but a market that can grow.
This is also why the protocol belongs to SaaC and not to any one product. SaaC says software is hired. SaaCIP says what every hire has in common.
What SaaCIP covers, in plain words
SaaCIP follows a hire from start to finish, in six steps.
Every SaaC hire, in six steps
- 1Agree the termsWhat it may read, do and send, its highest autonomy, and whether it uses an AI model. Both sides keep a signed copy.
terms - 2StartA one-time token, used once. From then on its credentials work for one hirer only, and can be cut off at any moment.
enrol - 3Do and report the workEach piece of work reported once, under its own reference, so a retry never duplicates it.
report - 4Stay in controlObserve, report, act after approval, act alone within limits. The hirer can lower the level; nothing can raise it.
autonomy - 5Leave evidence, learnA signed, chained receipt for every step that matters. People judge the work, and their judgements flow back.
receipts - 6Give an accountA statement at the end: what it found, how often people judged it right, what actions ran. It feeds the track record.
statement
The same six steps whether the capability runs in the provider’s cloud or, as a Resident SaaC, inside the hirer’s own environment.
- Agree the terms. Before anything happens, the capability states what it will read, what it may do, what data leaves and to where, whether it uses an AI model, and the highest level of autonomy it may use. The hub checks these terms against the hire the hirer created, and the capability records them in its first signed receipt, so both sides hold the same words.
- Start. The hirer creates the hire and hands over a one-time token. The capability uses it once, and from then on its credentials work only for that hirer and can be cut off at any moment.
- Do and report the work. Each piece of work is reported once, under its own reference, so a retry never duplicates it. Updates are added, not repeated.
- Stay in control. There are four levels of autonomy: observe, report, act after a person approves, and act alone only for reversible actions the hirer marked as allowed to run alone, within a daily limit. The hirer can lower the level at any time; nothing can raise it above what was agreed. Actions come only from a list the hirer approved, and an AI model may at most pick from that list.
- Leave evidence and learn. Every step that matters leaves a signed receipt, chained to the one before, kept where the hirer can check it. People judge the work, real issue or false alarm, and those judgements flow back to the capability.
- Give an account. The hire ends with a statement: what was found, what was reported, how often people judged it right, and what actions ran. That statement is the basis for a review, a renewal or a bill, and it feeds the capability's track record.
If you have read the Agentic Economy series, the vocabulary will feel familiar. That is deliberate.
| Agentic Economy term | Under SaaCIP |
|---|---|
| Manifest, the capability's CV | States the protocol, the kinds of hire it accepts, its highest autonomy level and its declared actions |
| Hire-token, the contract for one job | The terms of the hire, checked by the hub and recorded in the capability's first signed receipt |
| Receipt, the payslip | A signed, chained record of every step that matters |
| Registry track record, the reference | Built from statements, hire after hire |
One core, more than one way to run
Capabilities will not all run the same way. Some will run in the provider's cloud and be called per task. Others, like the Resident SaaC, will live inside the customer's environment for months. So SaaCIP has a core that every hire follows, and profiles for each way of running.
Version 0.1 defines the first profile, Resident SaaC (rSaaC). On top of the core, it says the capability calls out and nothing calls in, that it goes to the data rather than moving the data, that its records stay in the customer's environment, and how it connects to sources such as cloud logs, a search store or an MCP server. A second profile, for capabilities hired from a registry and run by the provider, is next on my list.
What leaders can ask today
You do not need to adopt SaaCIP to use its questions. Whoever offers you an AI capability, whether a vendor, a partner or your own team, can be asked these five:
- Can I see exactly what it will read, do and send, before it starts?
- Can I lower its permissions, or stop it, at any moment, without asking you?
- Does it leave evidence I can check myself, that nobody can quietly change?
- Do my people's judgements of its work change how it behaves?
- If I move to another provider, do I keep my controls, my records and my history?
If the answers are vague, you are not hiring a capability. You are buying a black box.
The EU AI Act question
The EU AI Act raises questions about human oversight, record keeping and transparency for some AI systems. As I read it on 30 October 2026, a protocol that records the agreed terms, keeps a person able to approve and stop actions, and leaves signed evidence of each step may help an organisation answer some of those questions. Whether it does, and whether a given system is covered at all, depends on the system and its use. SaaCIP makes no claim of compliance with any law, and that judgement belongs with qualified lawyers.
For architects: the short version
- Identifier
saacip/0.1. The core is one document; each way of running a capability is a profile with its own. In the first, the Resident profile, the capability runs inside the hirer's environment and always calls the hub over HTTPS; nothing calls in. - Form. SaaCIP is not one file. It is a set of documents and messages, each with a JSON Schema: a capability manifest, a declared actions file, the terms of the hire, receipts, outcomes and statements. People may write the manifest and the declared actions in YAML; everything sent, stored as evidence or signed is JSON, and receipts are JSON Lines. Errors are problem details (RFC 9457).
- Lifecycles. Three state machines: the hire (pending, active, released, ended, revoked), each work item (found, recorded, deferred, open, closed, applied), and each declared action (proposed, suggested, awaiting, approved, rejected, refused, executed). Every transition that leaves evidence writes a receipt of a named kind.
- Enrolment swaps a one-time, expiring enrolment token for a credential. The hub stores only hashes of both, and each works for one hirer only. The terms the capability sends are authoritative: if they disagree with the hire the hirer created, the hub refuses rather than silently changing them.
- Reporting is idempotent by a reference the capability chooses. What the hub wants the capability to know waits in an inbox until the capability confirms it.
- Autonomy has four levels. The effective level is the lower of the agreed ceiling and the hub's current setting.
- Receipts are signed with Ed25519 over the canonical JSON (RFC 8785) and chained with SHA-256.
- Extensible by design. Versions are negotiated at enrolment. Receivers ignore what they do not understand, unless a document marks it critical. Anyone can add data under their own reverse domain name, and new profiles follow a written template.
- Conformance is checkable: every document and message has a schema, a published validator reports what fails, receipts verify as a chain, and the specification names what a hub must refuse. A conformance claim names the version and the profile. The specification names no products; I have tested it against a private build of my own, and the published examples come from that work with every name made up.
- Other protocols are welcome inside it: a capability can read through MCP servers and answer assistants over MCP, can be reached over A2A, and its statements can be what a payment points to.
The full specification has the lifecycles, the fields, the calls, the extension rules and the reasoning behind each choice. The Resident profile is its own document, and the examples are walked through step by step, every document and message of one hire shown where it is produced.
What is still open
Version 0.1 is a draft for comment, not a standard. It is open: the text is under the Creative Commons Attribution 4.0 licence and the schemas, examples and validator under the Apache License 2.0, and there are no patents to license. The second profile, a shared way to publish track records without sharing anyone's data, and who looks after SaaCIP as it changes are all open. I would rather it changed now, with others' help, than later, on its own.
Coming next
Part 4 of this series, Case Study: Resident SaaC, puts SaaCIP to work: a capability that lives inside a customer's environment, watches their systems and answers for every action. After that, the SaaC series continues with the Capability Maturity Model, from L0 to L4.
If you are building AI capabilities and would like to test SaaCIP against your own, or tell me where it is wrong, message me on LinkedIn.
The small print
SaaCIP is my own work and ongoing research. The specification is published under the Creative Commons Attribution 4.0 licence, and its schemas, examples and validator under the Apache License 2.0, so anyone may use and build on it. I hold no patents on it. It is not a standard, and it has no link to the organisations behind MCP, A2A, AP2, ACP or x402, which are named only to show where SaaCIP sits. Where I mention the EU AI Act, I describe the questions it raises as I read them on 30 October 2026, not how it applies to any organisation; this is not legal advice.
Important notice. This article is part of my ongoing research into the Agentic Economy and reflects my thinking at the time of writing. It is shared in good faith, for information and discussion. It is not legal, regulatory, technical, financial or other professional advice, and it is not a verdict on how the EU AI Act or any other law applies to any organisation, system or situation. Laws, guidance, technology and my own research all move on, and others may reach different conclusions. The examples, designs, diagrams and technology choices show one possible approach. Before relying on, adapting or applying any part of it in your own situation, you must test and verify it, design it for your own architecture, and take independent expert advice, including from qualified lawyers and from your own IT, security and data protection specialists. Any decision to act on it, and its consequences, rest with you. To the fullest extent permitted by law, the author accepts no responsibility or liability for any loss, damage or consequence arising from any use of, or reliance on, this article, which is provided without any warranty of accuracy, completeness or fitness for a particular purpose. Reading it does not create a professional or advisory relationship with the author. The views expressed are the author’s own.