Documentation
Build for dealmakers. One signed object — from multi-party deal to on-chain settlement.
What is YieldFabric?
YieldFabric is a platform for dealmakers — multi-party deals, structured commitments, negotiated arrangements that need to actually happen, not just be filed away.
The thing that makes YF distinct from anything else: the signed agreement is the executable. The legal terms parties agree to and the on-chain actions that carry them out are the same object. No gap between "what we agreed" and "what got done."
You build the user experience. YF handles the rest under the hood — identity, AI agents that help draft and propose, multi-party signatures, structured deal lifecycle, conditional execution, on-chain settlement, and the audit trail that ties it all together.
How to use it
Three ways, in order of how much you want to write yourself.
Drop in the wallet
@yieldfabric/wallet — React component. Identity, signing, the moment a party commits to an agreement.
import { WalletProvider, LoginForm, SignatureDrawer } from '@yieldfabric/wallet'
export default function App() {
return (
<WalletProvider config={{ onNavigate: router.push }}>
<LoginForm />
<SignatureDrawer /> {/* prompts users when an agreement needs their signature */}
</WalletProvider>
)
}Best when your users need to log in, hold an identity, and sign things — the signatures that make agreements binding.
Drop in the conversational widget
@yieldfabric/terminal — React widget for the AI surface. Agents help parties draft and refine; humans approve.
import { ExpandableTerminal } from '@yieldfabric/terminal'
<ExpandableTerminal
config={terminalConfig}
onCommandExecute={handleCommand}
/>Best when you want AI agents inside your app that can read documents, help draft proposed terms, and route user-approval steps — without building the chat / approval UI yourself.
Call the API directly
HTTP REST + GraphQL. Same JWT everywhere: the GraphQL gateway handles reads and mutations.
# Propose a deal — parties, terms, plan
curl -X POST $YF_GATEWAY/graphql \
-H "Authorization: Bearer $TOKEN" \
-d '{ "query":
"mutation { dealFlow { proposeDeal(input: { ... }) {
deal { id status planHash parties { entityId } }
} } }" }'Best when you need behavior the SDK + widget don't cover — custom deal templates, your own approval UI, server-side automation, integration with external workflow tools.
When to use it
YF earns its weight when the agreement and the execution both matter — and reach for something simpler when only one of them does.
Reach for YF when
- Two or more parties need to agree on something with substance — terms, schedules, conditions, obligations — and then have it actually execute.
- The legal text and the execution must be one object. The hash a party signs over is what runs.
- You want AI to help draft, propose, and refine the deal — without letting AI execute anything. Humans sign; the system carries out.
- Audit trail matters — regulators, finance, compliance, dispute resolution. Every state change linked back to the signed plan.
- Privacy matters — counterparties shouldn't see each other's amounts, but verifiability and integrity must hold.
Use something else when
- You just need to take card payments from customers → Stripe.
- You need a chatbot, no agreement or execution involved → OpenAI / Anthropic API direct.
- You need someone to sign a PDF with no execution after → DocuSign.
- You need treasury management without negotiated multi-party agreements → standard banking.
- You're building pure DeFi with no humans negotiating anything → Solana / EVM directly.
The niche: when separately, the legal layer (DocuSign-shaped) and the execution layer (Stripe-shaped, or chain-shaped) leave a gap that humans or ops have to bridge — and that gap is where mistakes, delays, and disputes live. YF closes the gap by making them one object.
Get started
Pick a starting point based on what you want to do first.
Quick Start
Run an end-to-end flow against a live deployment — auth, workspace, drafted proposal, signature, execution.
Overview
The platform's shape from a builder's perspective. The five things you'll work with. What you don't have to write yourself.
Building with YieldFabric
The most-common operations as curl + GraphQL. Errors, idempotency, common pitfalls. Pragmatic, no theory.
API Reference
Auth, payments, agents — three service specs with full type info and code samples for every operation.
Go deeper
When you need to understand a specific capability before building with it.
Deal Management System (DMS)
The heart of the platform. Deal lifecycle (Proposed → Signed → Active → Completed), DealPlan as the typed hashable artefact parties sign over, rendered legal-style agreement.
Agents, knowledge & workspaces
Where parties + AI work out the agreement. Working groups, threads, agents as edge translators, knowledge graphs, the Intent → Confirm safety boundary.
Collateralisation
Repo, contingent contracts, rehypothecation. When the executed deal involves locking and releasing assets against repurchase obligations.
Why YF is shaped this way
If you want to understand why agents propose and humans sign — the structural argument under the architecture.