Notes that go with SaaCIP 0.1: what early readers said, what it clarifies, and what version 0.2 contains. Not part of the specification; the 0.1 documents stay as published.
SaaCIP 0.1: early feedback, and the plan for 0.2
Notes, not normative. The 0.1 text is unchanged; this page records what readers said in the first week, what it clarifies, and what version 0.2 contains. Version 0.2 was published on 6 November 2026 at /saacip/; this page is kept as written on that day
Date 6 November 2026; updated the same day after a second reading, see the end of the pageAuthor Imtiaz Hassan
At a glance
| What this is | What early readers said about SaaCIP 0.1, what each point changed, two clarifications that apply to 0.1 as written, and the plan that became 0.2. |
|---|---|
| Status | Notes, not normative. Written 6 November 2026 and kept as written; 0.2 was published the same evening. |
About this document
Applies to. SaaCIP 0.1, the core, and the Resident SaaC profile, both published 30 October 2026
Licence. CC BY 4.0, as for the specification text
Contents
- Why this page exists
- Early feedback, and what each point changes
- Clarifications to 0.1
- What 0.2 will contain
- How to comment
- Changes to this page
Why this page exists
SaaCIP 0.1 went out as a draft for comment, and comments came: on the LinkedIn thread, in private messages, and from an independent review of the whole text. The 0.1 documents are not edited in response, on purpose. They were captured by the Internet Archive on the day they were published, people have cited them, and a specification that changes under its readers is worse than one with known gaps. So this page does three things. It records the feedback and says what each point changes. It gives two clarifications that apply to 0.1 as written and will be folded into the text in 0.2. And it sets out what 0.2 will contain, so that the plan is public before the work is done.
"Early feedback" is the right name for it: one public thread, a handful of conversations, one independent review. It is not a consensus of any kind, and this page does not claim it is.
Early feedback, and what each point changes
Receipts prove integrity, not truth
The point: receipts are signed by the capability, and the statement is the capability's own account. A chain that verifies shows the record was not altered afterwards; it does not show the capability told the truth. People's judgements (outcomes) help, but the strongest claims about a track record need something the hub, or a third party, signs.
This is right, and 0.1 says as much: section 7.5 calls the statement "the capability's account of the hire, built from its own receipts", and asks only that it be checkable against them. Two things already narrow the gap: the hub holds checkpoints (receipt_head in every heartbeat), so a capability cannot rewrite history without the hub noticing; and every judged work item was judged by a person at the hub, not by the capability.
What changes in 0.2: the hub signs the final statement it accepted and the outcomes it recorded, and returns that signature with the statement response. A track record then rests on two signatures, the capability's over its own account and the hirer's hub over what it received, and a registry is told to trust the second. One new member, one new rule, no change to anything that exists.
A second reading pushed back on this: a hub signature shifts trust, it does not remove it. Once a registry relies on the hub, a hirer could understate a provider's outcomes, for example in a dispute over payment. Agreed, and so the capability's own signed statement is not replaced by the hub's. The two are separate documents, and when they disagree, the disagreement is itself a signed fact that a registry records rather than resolves by preferring one side. How a registry handles that case belongs in the registry document.
The outcome vocabulary is narrow
The point: real and false_alarm fit detection and incident work. They do not fit work that produces something, such as drafting, coding or analysis, where the judgement is about quality, not about whether an alert was real. That shows the use case the author had in mind and limits how general the protocol is.
Also right. The reference build that 0.1 was tested against watches logs, and its vocabulary leaked into the core.
What changes in 0.2: outcome values become profile-defined, with a core minimum of accepted and rejected. The Resident profile keeps real and false_alarm as its values. A profile for work that produces something can add its own, for example accepted, revised, rejected. The same applies to action_worked. Nothing valid under 0.1 becomes invalid.
With one rule, from the second reading: every profile-defined value MUST say which core value it counts as, accepted or rejected, so that the statement counts (such as share_real) are computed the same way in every profile and a registry can compare them. Without that rule, profile-defined values would break the comparability that the registry work depends on.
The common case is not covered
The point: a capability that runs inside the hirer's environment is the cleanest case to specify, and 0.1 specifies it. Most vendors will host the capability themselves, and that profile is still an open point. That is where data residency and trust get hard.
Agreed, and it is open point 1 in 0.1 (a second profile, for capabilities run by the provider). Resident came first because it is the case where SaaC differs most from SaaS, and the one the reference build exists for.
What changes in 0.2: a Hosted profile. The capability runs at the provider's, the hub stays at the hirer's, the direction of every call stays outbound from the capability. What changes is that residency moves from the architecture to the terms: data_leaving and the model statement carry the whole privacy story, and the receipts show what left. Several readers asked how SaaCIP answers the "our data must not leave" condition that many companies set; the Resident profile answers it by design, and the Hosted profile will answer it by terms and evidence.
The second reading pointed out that this brings the first problem back: in the Hosted profile the receipts that say what left are written by the capability, so they are self-reported. That is true and the 0.2 text will say it plainly, as a split. What the hirer sent to the provider leaves from the hirer's own edge, so the hirer can log it and check it against the terms. What the provider then did with it, including what it sent to a model, is only ever the capability's own account. The Hosted profile will name the place where a stronger attestation could plug in, such as a signed usage record from the model provider or an attestation from a confidential computing environment, as an extension point, not as a promise.
Comparable track records depend on registries
The point: comparing providers needs shared registries and agreement on how outcomes are counted, and both are deferred.
They are, and they stay deferred past 0.2. The hub signature above is the first piece: a registry can only compare what somebody other than the capability has signed. How a registry lists capabilities, what it may publish without sharing any hirer's data, and how counts are made comparable are the author's current research and will be published as their own document.
Adoption is the real test
The point: a single-author 0.1 with one implementation and no governing body can be sound and still lose to extensions of larger protocols. Two working hubs from different parties would do more than more text.
Agreed without reservation. The hub side of the Resident binding is seven calls, which makes an adapter for a help desk or work tool people already run a small project. The author is taking the specification to the IETF as an individual Internet-Draft and to the agent protocol discussions there, where the people who would build a second hub are. Anyone who builds one is asked to say so.
The second reading added, fairly, that an Internet-Draft gets the text read but builds nothing, and that a small, open hub adapter for a help desk people already run would do more for adoption than any amount of text. Noted; whether and when such an adapter is published is not decided, and this page will say when it is.
Does the model follow the agreement?
The point, from a reader: smarter models tend to over-reach, add assumptions, and not follow rules exactly. Does the protocol survive that?
It is the design principle, and it is worth stating plainly because 0.1 spreads it over sections 9.2 and 11. SaaCIP does not rely on the model following rules. The terms, the autonomy level and the declared actions are enforced by the capability's own code, outside the model. The model is asked to do 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 are filled from an allowlist and 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 daily limit catch, or write an over-confident report, which a person judges and which counts against the track record. Receipts are written by the code, not the model, so the record is of what ran. The protocol cannot make a model's findings correct; it makes sure a wrong one is reported, judged, counted, and never becomes an unapproved action.
Token cost
The point, from the same reader: what does the protocol cost in tokens for complex workflows?
Almost nothing. The protocol's messages are small JSON, sent rarely; receipts are written locally with no model. Tokens are spent on the capability's actual job, and the terms say which model is used and where it runs; a capability doing simple pattern work can declare model: offline and use none. The cost of a complex workflow belongs to the capability, not to the protocol, which sees the work items and the actions and not the reasoning in between.
Clarifications to 0.1
These apply to 0.1 as written. They add no requirement and change no member; they say in plain words what the text left to be inferred. Both will be folded into the text in 0.2.
A capability is hired; a skill is used
The word "skill" now has two settled meanings in the field: a packaged set of instructions and tools that a model loads to do a task, and the skills list on an A2A Agent Card. Both are things an agent has. A capability in SaaC is something a hirer hires.
A skill is something an agent can do: 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 a skill. It is a line on a CV.
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, and gives an account at the end. It may use many skills, call tools over MCP and reach other agents over A2A; those are how it does the job, not what it is. The capability manifest is its CV, and skills are lines on it.
The test for any 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.
Relation to the Handshake Protocol
Section 14 of 0.1 relates SaaCIP to MCP, A2A, the payment protocols and telemetry standards. One protocol published earlier in 2026 belongs in that table and was not in it: the Handshake Protocol (handshake.ai; version 0.2.0 first published 15 March 2026). In its own words it provides "cryptographic identity, verifiable delegation, and signed action receipts for AI agents" and "wraps MCP / A2A / OAuth 2.1 / AP2, doesn't replace them". Its architecture covers one action: a principal signs a delegation, an agent presents it, a service executes the action and signs a receipt, a verifier checks the receipt.
The row that 0.2 will carry:
| Protocol | Carries | How SaaCIP relates |
|---|---|---|
| Handshake Protocol | Identity, delegation and a signed receipt for one action | A Handshake action is one step inside a SaaCIP hire. The two use the same standard primitives (Ed25519, SHA-256, RFC 8785) and sit well together: Handshake under the action, SaaCIP around the hire. 0.2 will say how a hire's receipt references an action's |
What 0.2 will contain
In the order they will be written, without dates. 0.2 is published when the text is complete and at least one person who is not the author has read it.
- Hub-signed statements. The hub signs the final statement and the outcomes it recorded; the signature travels with the statement; registries are told to trust it. The capability's own signature stays, and a disagreement between the two is recorded, not resolved.
- Profile-defined outcomes. Core minimum
acceptedandrejected; each profile adds its own, and every added value says which core value it counts as; the Resident profile keepsrealandfalse_alarm. - The Hosted profile. The capability at the provider's, the hub at the hirer's, residency carried by the terms and the receipts, with a plain statement of which evidence the hirer can check and which is the capability's own account, and an extension point for attestation.
- Composition with an identity layer. How a per-action delegation and receipt from a protocol such as Handshake sits under a hire, and how the hire's receipt references it.
- The two clarifications above, folded into sections 2.2 and 14.
- Small corrections found in the first weeks of reading, listed in the 0.2 change log, none of which changes the meaning of 0.1.
After 0.2, and as its own document: what a registry of capabilities needs from a statement, and how track records are made comparable across hirers without sharing any hirer's data.
How to comment
Comments on the LinkedIn posts, or directly on LinkedIn. Anyone building a capability or a hub against 0.1 is especially welcome; a second implementation from a different party is worth more to this protocol than anything the author can write.
Changes to this page
6 November 2026, later the same day: after a second reading of this page, four paragraphs added (under receipts, outcomes, the common case and adoption) and items 1 to 3 of the 0.2 list widened accordingly. Nothing removed. The 0.1 documents are unchanged.
6 November 2026, evening: version 0.2 published, with the Resident profile at 0.2, the Hosted profile, the 0.2 schemas and examples, the FAQ and the capabilities page. The status row above says so; the rest of this page is kept as written.
The views here are the author's own. The 0.1 documents remain as published.
Important notice. This specification 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 specification, 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.