SAP SDK v0.9.3 → v0.10.1: From Identity Bridge to Reliable Execution
This release cycle finalizes the Metaplex Core bridge and strengthens the payment layer with stricter validation and deterministic settlement flows, improving consistency across agent execution.
From identity bridge to reliable execution
Over the past few releases, the SAP SDK has gone through a natural progression.
It started with connecting agent identity across systems. Then it moved into making execution and payments work reliably under real conditions.
This update cycle is less about new features, and more about making the existing system hold up when agents actually run.
v0.9.0 → v0.9.3 — Completing the identity bridge
With v0.9.0, SAP introduced the idea of linking agent identity to Metaplex Core assets.
An agent could attach an AgentIdentity plugin to a Metaplex asset, which points to a live JSON representation of its SAP state. This made it possible for different systems to reference the same agent without duplicating data.
v0.9.3 builds directly on that foundation. It doesn’t change the concept, but it makes the flow stable and usable in practice.
What changed in v0.9.3
The main improvement is reliability.
In theory, linking identity is straightforward. In practice, a few things tend to break. RPC endpoints behave differently, some require authentication, and multi-step flows create unnecessary points of failure.
v0.9.3 smooths this out.
It adds proper support for RPC headers, which ensures that assets behind authenticated endpoints can still be read correctly. It also introduces simpler, more direct flows for creating and linking identity, so developers don’t have to coordinate multiple steps manually.
Another important addition is verification. Instead of assuming everything is connected correctly, the SDK now provides a way to check the full link between SAP, the Metaplex asset, and the external JSON.
The overall result is that the identity bridge introduced in v0.9.0 becomes something you can rely on, not just something that works in ideal conditions.
v0.10.0 — Making payments and settlements more robust
Once identity is handled properly, the next step is execution.
More specifically, how agents get paid for the work they perform.
v0.10.0 focuses on this part of the system and introduces a set of changes that make payment flows stricter and more predictable.
What improved
The SDK now validates more things upfront.
Payment tokens are checked before execution, so unsupported tokens fail early instead of causing issues later. Agent stake is also enforced as part of the flow, rather than being treated as an implicit requirement.
These changes might seem small, but they prevent a lot of edge cases that only show up in production.
A clearer structure for settlements
Another important improvement is how settlements are tracked.
Instead of loosely linking payments to execution, each settlement now has a clear reference derived from the escrow and the executed service. For batches, a root is computed over all calls to represent the entire group.
This makes settlements easier to trace and verify. It also creates a consistent structure that works the same way across different use cases.
Why this matters
With these changes, the payment layer becomes more predictable.
There are fewer hidden assumptions, fewer silent failures, and a clearer connection between execution and settlement.
Some function signatures were updated to support this, but the goal is simple: make correct usage the default.
v0.10.1 — Reducing friction
After tightening the core flows, v0.10.1 focuses on making the SDK easier to use.
Some of the new utilities introduced in v0.10.0 were not easily accessible, which made integration slightly more complicated than necessary.
This release fixes that by exposing them at the top level and updating the documentation to match the new structure.
It’s a small update, but it makes a noticeable difference when building with the SDK.
Bringing it together
These releases follow a clear progression.
v0.9.0 introduced the identity bridge. v0.9.3 made it stable and easier to work with. v0.10.0 improved how payments and settlements behave. v0.10.1 made the overall experience smoother for developers.
Each step builds on the previous one without changing the direction.
Final take
The SAP SDK is moving toward a system that works reliably in real conditions.
Agents can be identified across systems without duplication. They can execute tasks and settle payments with a clear structure. And developers can integrate these flows without dealing with unnecessary complexity.
That’s what this release cycle is really about.
Change Log: https://github.com/OOBE-PROTOCOL/synapse-sap-sdk/blob/v0.11.0/CHANGELOG.md