Invoica × OOBE Protocol: Bringing Invoice and Settlement into Agent Workflows
With Invoica now part of the OOBE stack, agents can move beyond execution and start handling real payment flows. Invoice creation and on-chain settlement are now built directly into agent workflows.
We are partnering with Invoica to bring invoice creation and on-chain settlement directly into the OOBE stack.
Invoica is now integrated into the Synapse SDK and connected to the Synapse Agent Protocol (SAP). This allows agents to handle not only execution, but also payments as part of the same workflow.
What’s New
With this integration, agents can:
- Create and manage invoices programmatically
- Track invoice status in real time
- Detect and verify on-chain settlements
- Execute payment flows without manual intervention
Invoica uses the x402 payment protocol for on-chain settlement, an emerging HTTP-native standard for agent-to-agent micropayments.
All of these capabilities are now accessible directly through the Synapse SDK.
These capabilities are now available directly through the Synapse SDK.
Available in the Synapse SDK
The integration introduces native Invoica tools that follow the same structure as the rest of the Synapse stack:
- invoica_createInvoice
- invoica_getInvoice
- invoica_checkSettlement
- invoica_detectSapSettlement
From a developer perspective, this is just another module in the SDK. No custom setup required.
Integration with Synapse Agent Protocol (SAP)
Invoica is also integrated into the Synapse Agent Protocol.
This means agents within SAP can include invoicing and settlement directly in their interactions. Payments are no longer an external step, but part of the protocol-level flow.
Agents can now:
- Generate invoices during interactions
- Detect and verify payments on-chain
- Embed settlement logic directly into workflows
- Execute payments autonomously between agents or users
Invoica’s settlement detection works across both EVM (via x402 on Base) and Solana-native SAP flows, making it chain-agnostic at the workflow level.
From Execution to Transactions
Most agent systems today stop once the task is done.
They search, analyze, generate something, execute it and that’s it. The actual payment part usually sits somewhere outside the flow.
With Invoica, that gap is gone.
After execution, agents can immediately create an invoice and track the payment on-chain without leaving the workflow.
So instead of just doing tasks, they can now complete the full cycle, including getting paid.
Quick Start
import { SynapseClient } from '@oobe/synapse-client-sdk';
const synapse = new SynapseClient({ / config / });
const invoice = await synapse.invoica_createInvoice({ amount: 10, currency: 'USDC', description: 'Agent execution fee' });
const settlement = await synapse.invoica_checkSettlement({ invoiceId: invoice.id });
console.log(settlement.settled); // true
Developer Experience
The integration is designed to be simple.
Developers can access Invoica tools through the Synapse SDK and combine them with:
- Data access via Synapse RPC
- Execution tools
- Coordination through SAP
Everything works within the same environment. No need to build separate payment infrastructure.
Why This Matters
Payment handling is still one of the main gaps in agent systems.
Invoica was built autonomously by 18 AI agents in 6 days, with a 96.4% on-chain settlement approval rate in production.
With this integration:
Payment and settlement logic becomes part of the workflow itself Agents can verify and execute transactions without external coordination Value transfer happens directly within agent interactions
Invoica provides the payment layer, while OOBE integrates it into end-to-end agent workflows.
What’s Next
This integration is part of a broader direction: enabling agents to operate end-to-end within a single flow.
We will continue expanding the stack with integrations that improve usability, reduce complexity, and extend what agents can do.
Resources
Invoica
Website: https://www.invoica.ai/
Github: https://github.com/skingem1/Invoica
Synapse SDK Integration PR: