TheSoftware LensSee engineering differently

Not part of the specification: the questions people ask about SaaCIP, answered in plain words, with links into the text for the detail.

SaaCIP in plain words: questions people ask

Explanations, not normative. Where this page and the specification differ, the specification is right and this page has a mistake

Author Imtiaz Hassan

At a glance

What this isThe questions people ask about SaaCIP, answered in plain words, with links into the specification for the detail. Not normative.
Read it ifYou want to know who does what (one table), what SaaC is, what a capability is and is not, where the AI is and when you need it, why the hub contains no AI, where the data goes, how capabilities work together, and where to start.

About this document

About. SaaCIP, the SaaC Interoperability Protocol, versions 0.1 and 0.2

Licence. CC BY 4.0

Who does what, in one table

Who What they do Who writes or runs it
The provider Builds the capability, publishes its CV (the manifest) and stands behind the job. A SaaS vendor packaging a job it can take responsibility for, or anyone else. The provider writes the capability; the protocol part comes from the reference client.
The hirer Your organisation. Creates the hire, sets the terms and the autonomy level, issues the credentials, judges the work, keeps the evidence, pays for the result. You. The effort goes into the terms and the judging, not into code.
The hub Your front desk: where a hire is created, where reports arrive, where your people approve actions and judge findings, and where the record is kept. It contains no AI. The reference hub (it exists and is to be released under Apache 2.0; it is not public yet), or an adapter in a tool you already run.
The adapter A hub built into a help desk or work tool (a ticket queue, Jira, ServiceNow): a report becomes a ticket, an approval request a ticket with two buttons, a judgement an outcome. Generic: one per tool, none per capability. Written once per tool by whoever wants it: the tool's vendor, a hirer, an integrator, the community. The reference implementation includes one for Jira Cloud.
The capability The thing you hire. Does the job within its terms, reports, asks before it acts, writes receipts, gives an account at the end. Runs in your environment (Resident) or at the provider's (Hosted). Built by the provider; in the Resident profile, deployed by you.
The person at the hirer Approves or rejects each action, judges each finding, lowers the level or ends the hire at any time. One of your people, in the tool they already use.
The model The AI, if the job needs one: reads messy input, explains a pattern, chooses from the declared actions. It can never raise its own level or write a command. Inside the capability. Which model and where it runs is written in the terms before the hire starts.
The credentials The keys the capability needs for your sources and systems: scoped to one source or one action, revocable, named by label. Issued by you, never by the provider, and never carried over the protocol.
The registry Where CVs are listed and, later, track records compared. Today a draft board on this site; the rules for what a registry may publish are a document still to come.

The shortest way to hold it: the hub is the receptionist at your front desk. It takes messages, puts them in front of the right person and writes down the answers; it understands nothing of the job. The capability is the specialist you hired, and it knows the job. One receptionist serves every specialist, which is why one adapter serves every capability.

What is SaaC, in one sentence?

Software as a Capability: instead of buying software and using it, you hire a capability to do a job, on terms you set, and it answers for the job with evidence. SaaS sells access; SaaC sells judged work.

What is a capability, and what is not one?

A capability is a unit of hireable work: running software that takes a job on agreed terms, works within limits a person set, leaves signed evidence, is judged by the people who hired it, and gives an account at the end. "Keep our timesheets complete and correct every week" is a capability. "Log time" is an API call.

A skill is something an agent has: a tool it can call, a procedure it has learned, a set of instructions it loads. It has no terms, no autonomy level, no receipts and no track record, and nobody hires one. A capability may use many skills, tools and protocols to do its job; the capability manifest lists them the way a CV lists them. The test for a borderline case: can it be hired, judged and released? Then it is a capability. Can it only be invoked? Then it is a skill or a tool.

Who are the two sides?

The provider builds and offers the capability. The hirer is the organisation that hires it, owns the data and the environment, and is in charge. The hirer's side of the protocol is called the hub: the place where a hire is created, where the capability's reports arrive, where people approve actions and judge findings, and where the record is kept. A help desk or a work tool can be a hub, through an adapter.

What does a SaaS vendor have to do to offer a capability?

More than wrapping its API, less than rebuilding its product. It has to package a job it can take responsibility for, built on the product it already has, and put the hireable form around it: the terms (what it may read, what leaves, which model, how much autonomy), the declared actions (the only things it may ever do), receipts for every step, outcomes it learns from, and a statement at the end. The protocol layer is the same for every job, which is why a reference client exists; the job is the vendor's.

What does a hirer have to build?

Nothing, if an adapter exists for a tool it already runs: it installs the adapter, creates a hire, hands the capability a one-time token, and spends its effort where it matters, on the terms of the hire and on judging the work. Until adapters exist for common tools, a hirer runs the reference hub, which is a small program with its own pages. Either way the hub needs no AI; it receives seven kinds of call, shows them to people, and carries their decisions back.

Is the adapter generic, or one per capability?

Generic, by design. The seven calls and the shape of every document are fixed by the specification, so a Jira adapter knows how to turn a report into a ticket, an approval request into a ticket with two buttons, and a person's judgement into an outcome, and it does that for every capability from every provider. What varies by capability lives in the terms and the declared actions, which the adapter shows and never interprets. One adapter per hirer tool, zero per capability.

Who runs the model?

The capability, and only if its job needs one. Where the model runs is written in the terms (model) and the hirer agrees to it before anything starts. In the Resident profile the capability runs inside the hirer's environment, so the model runs where the hirer puts it, and the hirer can see every call that leaves. In the Hosted profile the provider runs the capability and therefore the model, and that is self-reported in the receipts; the Hosted profile says so in plain words. A capability that needs no model says model: offline. The hub, the adapter and the hirer's tools never run one.

Where is the AI in all this, and when do I need it?

Inside the capability, and only when the job needs it. A capability that reviews invoices may use a model to read a scan; one that watches logs may use a small model to explain a pattern in words; one that checks timesheets or certificate dates needs none, because rules do the whole job. Everything around the capability has no AI at all: the terms of the hire, the autonomy level, the approvals, the receipts, the hub, your help desk and the statement at the end are ordinary software and people.

The practical rule: you need AI where the job needs judgement on messy input, and you do not where a rule can decide. You never have to guess which is which, because the terms name the model and where it runs before the hire starts, the capability's CV on the board says it in one line, and in the Resident profile the model runs where you put it. The capability proposes; your people decide.

Does the protocol rely on the model following rules?

No. The terms, the autonomy level, the declared actions, the daily limit and the receipts are enforced by ordinary code around the model, never by the model. The model is asked for two things: explain what it sees, and choose one action from the declared list. It cannot raise its own autonomy, add an action or write a command; parameters come from an allowlist and commands run without a shell; text from sources is data, never instructions. A model that over-reaches can at worst pick the wrong approved action, which the approval and the limits still catch, or write an over-confident report, which a person judges and which counts against the track record.

What does it cost in tokens?

Almost nothing. The protocol's messages are small JSON, sent rarely; receipts are written by code, with no model. Tokens are spent on the capability's actual job, and the terms say which model it uses and where. The protocol sees the work items and the actions, not the reasoning in between.

Where does the hirer's data go?

One Resident hire

One Resident hire: where each piece runsEverything that touches the hirer's data runs inside the hirer's environment. The provider is reached once, to fetch the image.PROVIDERImage registryprovider'sthe capability as a containerimage, versionedpulled once per deploymentNothing else at run timeno call-home, no telemetry,no copy of the hirer's data;the terms say what leaves,and the receipts show itHIRER'S ENVIRONMENT (its cluster or cloud account)Capabilityprovider's codeone instance per hire, one state storereads sources with a read-only credentialacts with a separate credentialwrites receipts; signs with the key belowall its calls go out; nothing listensReceipts volumeevidencereceipts.jsonl, append only;copied to write-once storagestays with the hirer after the hireSigning keyin the hirer's key service (production)or a file in the state folder (demo)Log sourceshirer'sfiles, ELK or Elasticsearch, cloud logs,an MCP server: whatever the connectormanifest names; read in place;ELK is a source, not something replacedHub, or an adapterhirer'sreference hub: SQLite + its own pagesor: the adapter that forwards to thehelp desk on the rightreceives the seven calls; no AIPeoplehirer'sapprove or reject declared actionsjudge findings: real or false alarmrelease or revoke the hireHelp deskhirer'sJira, ServiceNow, Zendesk: may be theirown SaaS; the adapter calls it outboundModelonly if the terms saya model in the hirer's account, a localmodel in the cluster, or an outside modelthe hirer explicitly allowed; the termsname it and the receipts show the callspull image7 callsread onlyif allowedOUTSIDERegistry (later)laterlists manifests andhub-attested statements;never the hirer's dataPaymentan invoice today;payment protocolslater (section 14)Direction of every protocol call: capability to hub. Direction of every data read: capability to source, inside the environment. Nothing crosses the boundary unless the terms say so.

One Resident hire: where each piece runs: the provider's image registry; inside the hirer's environment the capability, its receipts and key, the log sources, the hub or adapter, the people, the help desk and the model if the terms allow one; outside, a registry later and payment. Open full size

In everyday words: the capability lives inside your building, next to your logs; your hub (for example, your help desk) and your people stay where they are; only what the terms name may leave; the provider only supplied the capability, like an agency that supplied a contractor.

In the Resident profile, nowhere: the capability comes to the data and reads it in place, and only what the terms name in data_leaving may leave, which the receipts show. In the Hosted profile the hirer's data goes to the provider, and the terms say what it is used for and every onward recipient by name, including any model. The Hosted profile is explicit that what the hirer sent is checkable from the hirer's own side, and what the provider did with it afterwards is the capability's own account.

Does the capability need credentials to do its job?

Yes, for the sources it reads and the systems it acts on, and none of them ever travel over the protocol. They are issued by the hirer, never by the provider; scoped to one connector or one action and to the narrowest permission; revocable at any moment; listed in the terms by label and scope, never by value; and named by label in the receipts. Reading and acting always use separate credentials, so revoking the acting credential stops actions without stopping reports. In the Hosted profile they are short-lived as well.

Why would a hirer want this commercially?

Because it pays for judged work instead of access; because a trial means something, run in its own environment with actions simulated and every action waiting for approval; because the controls are the hirer's to turn down, not the vendor's; because its data stays, or what leaves is written down; because it gets evidence an auditor or an insurer can check without trusting the vendor; and because one hub takes any capability from any provider, so replacing one is a new hire, not a new project.

What is a receipt, and what does it prove?

A signed line for every step that matters, each carrying the hash of the line before it, kept in the hirer's environment. A chain that verifies proves the record was not altered after the fact. It does not prove the capability told the truth; that is why, from 0.2, the hub countersigns the final statement with an attestation of what it received and what it recorded, and a track record rests on both signatures.

What is an outcome, and who decides it?

A person's judgement of one work item: was the work right, and did the action help. The hub sends one only when a person made it. From 0.2 the words are profile-defined (a detection capability is judged real or false_alarm; a drafting capability on quality) and every value counts as one of two core values, accepted or rejected, so statements from different profiles can be compared.

Can several capabilities work together?

Yes, from 0.2, and the protocol's word for it is capability orchestration: several hires at one hub working on one purpose, coordinated only by the hub. A capability hands a work item to a role the hirer defined, the hub passes it to the hire that holds the role, the receiver takes it up under a ref of its own, and both sides leave receipts. No capability calls another, none can instruct another, and none can hire one; the hirer's hub decides the routes.

Does SaaCIP replace monitoring tools such as ELK?

No. A log store collects, stores and indexes logs; a log-watching capability reads what is already there, notices what is unusual, reports it and acts within declared limits. ELK is a source, not a competitor. What a hire does replace is the part of a vendor's offer that is sold as a seat and judged by nobody.

How does SaaCIP relate to MCP, A2A and Handshake?

MCP carries an agent's calls to tools. A2A carries tasks between agents. Handshake carries identity, delegation and a signed receipt for one action: a principal delegates, an agent presents its authority, a service runs the action and signs a receipt, a verifier checks it. All three answer the question "how does an agent make a call safely", and all three assume the picture they grew up in: software is a product, you hold a subscription or a seat, and an agent calls tools, talks to other agents, or proves it was allowed to act for you.

SaaCIP answers a different question: how does a hire work. What was agreed before day one (the terms), how much the capability may do on its own (the level and the ceiling), who can say yes, no or stop (a person at the hirer), what evidence it leaves (signed, chained receipts), how its work was judged (outcomes), and what account it gives at the end (the statement, countersigned by the hirer's own hub) so that the next hirer can see its record. None of the three defines any of that, because none of them is about hiring.

They are not competitors; they are the plumbing a hired capability uses. A capability can read through MCP, be reached over A2A, and carry out one action under Handshake. A Handshake action is one entry in a SaaCIP hire's receipts, and that is the only place the two overlap; section 14 of the specification says how an action_taken receipt references the action's own signed record. Protocols carry the calls. SaaCIP carries the hire, which is the unit a registry of hired capabilities has to agree on.

Is there a registry, or a place to find capabilities?

A first one, as a draft: the board lists capabilities by category, each with a CV, the terms of one hire and the diagram of that hire. Today every entry is a worked example by the author, and no track record is shown, because comparison only means something once hubs sign statements, which 0.2 adds, and the rules for what a registry may publish without sharing any hirer's data are a document of their own, still to come. Nothing is bought there and no payment passes through it.

Is SaaCIP a product, or tied to one?

Neither. The specification text is CC BY 4.0, the schemas are Apache 2.0, the reference implementation is to be released under the same licence, the author holds no patents on it, and the documents name no products. Anyone may implement it without asking.

Where do I start?

Read the core, then the working examples, which show one whole hire as it runs: one command starts a hub, a second runs a hire against it, and the hub's pages show what the person at the hirer sees. The reference implementation that runs them is not public yet. If you build a capability or a hub, say so; a second implementation from another party is worth more to this protocol than anything its author can write.

The views here are the author's own.

Important notice. This page 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 page, 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.