Built for the Velo × Noir Agentic Payment Hackathon ⚓
Freight advances for island shipping lines, guarded by an AI that can't overspend.
Ships get 85% of a freight invoice the day they sail. The agent decides when to pay; the chain decides how much it's allowed to.
Live website: https://sailo.pdyntech.com
Demo video (2 min): https://drive.google.com/file/d/1Cr3ncFfuCpBHOgGlcBWTrQGCC-COpCrC/view?usp=share_link
Pitch deck: https://drive.google.com/file/d/1oCUmO3Og3WVbIg9tBZ6OpIl-SqDwVyF2/view?usp=sharing
Team: Helena (haenlenaeean), Ethan (perrytot_), Dia Aviles (kirs6103)
Problem · Solution · Agentic Payment · Architecture · Noir · Velo · Testnet Proof · Repo · Run It · Env · What's Next · Credits
Philippine inter-island shipping lines pay for bunker fuel, port dues and crew before they leave port. The cargo owners they carry for pay on Net-60 to Net-90 terms. Small operators fill that gap with slow bank factoring or expensive informal loans. Lenders hold back because paper waybills can be pledged twice and no one can easily confirm the cargo arrived.
Sailo turns a freight invoice into a bounded on-chain escrow on Stellar.
- Invoice = device. The e-Waybill hash is registered on Noir's
device_registry. Each invoice gets its own escrow balance, and a duplicate registration is rejected on-chain. - An investor funds 85%. The shipowner gets the money the day the vessel sails, around ₱850,000 on a ₱1,000,000 invoice.
- Delivery is proven. The agent signs a berthing attestation when the ship sits inside the Cebu port geofence.
- The cargo owner pays through a normal Velo checkout. A verified Velo webhook triggers settlement: the agent repays the investor, returns the reserve to the shipowner and takes a 0.5% fee.
- The agent can't overspend. Every payout passes through Noir's
agent_registry, which enforces a per-payment cap, asset and expiry.
The site has two parts: a live Testnet demo at /app that runs the full loop on real Noir contracts, and a role portal where shipowners, investors and cargo owners sign up, tokenize, fund and pay invoices on one shared ledger. Portal invoices also run on Stellar Testnet: each shipowner and investor gets a Testnet wallet, and the same agent and Noir contracts register, fund, advance and settle them (sample invoices for new accounts stay simulated and are labelled).
| Step | From → To | Demo ₱ | XLM |
|---|---|---|---|
| LP funds escrow | LP → escrow | 850,000 | 850 |
| Advance | escrow → shipowner | 850,000 | 850 |
| Debtor pays | debtor → Velo → treasury → escrow | 1,000,000 | 1,000 |
| LP repayment | escrow → LP | 880,000 | 880 |
| Reserve rebate | escrow → shipowner | 115,000 | 115 |
| Protocol fee | escrow → treasury | 5,000 | 5 |
| Check | balanceOf(invoice) after settlement |
0 | 0 |
Testnet demo amounts at a fixed rate of 1 XLM = ₱1,000. The investor deploys 85% and earns 3% of face, so the return is 3.53% over 60 days (illustrative, not guaranteed).
The settlement agent decides when, whom and how much. Code checks everything it proposes before any money moves.
- The rules say what is permitted.
proposechecks the gates (escrow funded, AIS shows the vessel under way, a verified payment for the exact amount, a berthing attestation) and the hard limits (AIS dark over 12 h, more than 50 km off the sea lane). Payouts are by role (SHIPOWNER,LP,TREASURY), never by wallet address, and amounts always come from code. - An LLM decides whether to pay. When a payout is permitted,
decideasks the configured model, Gemini (askGemini) or Claude (askModel), with a strict JSON schema, to PROCEED or HOLD for ops review, weighing the evidence the rules don't judge: an AIS gap below the hard limit, the vessel reappearing off the lane, an ops review note. It can always decline a payout; it can never approve one the rules don't permit, or change an amount or payee. WithoutLLM_API_KEY, or if the model is unavailable, the rules decide and the decision record says so.- Try it: ▶ Run Demo: AIS goes dark on
/app. AIS drops out for about 8 h and the ship reappears about 14 km off the lane, under both hard limits, so rules alone would pay. The agent holds the settlement with its reasons; an operator's release makes it decide again with the review note.
- Try it: ▶ Run Demo: AIS goes dark on
- A deterministic executor checks it.
validateDecisionchecks the shape, thenexecutechecks the preconditions for the current state, recomputes every payout in integer math, maps roles to stored wallets and calls Noir. - Noir enforces the limits. Each payment is pre-checked with
checkPayment. Anything over the cap, expired or underfunded is refused before a fee is paid. - It fails closed. Any mismatch or refusal becomes a
HOLDthat reports what already landed.executenever throws.
| Decision | Preconditions (checked in code) | Payouts |
|---|---|---|
ADVANCE |
Funded, escrow ≥ advance, vessel underway, checkPayment.ok |
SHIPOWNER = 85% of V |
SETTLE |
Paid, webhook verified, amount == V, berthing attestation present, checkPayment.ok per payout |
LP = 85% + 3%, SHIPOWNER = rebate, TREASURY = 0.5%; sum == V |
HOLD |
Any precondition fails, a hard limit is reached, or the agent judges the evidence needs review | none (ops can release a judgment or hard-limit hold; the agent then decides again) |
DEFAULT |
Due date + grace passed, no payment | none (ops revokes and sweeps) |
flowchart TD
A["Shipowner tokenizes waybill"] --> B["Investor funds 85% escrow"]
B --> C{"AIS: vessel underway?"}
C -- No --> H["HOLD"]
C -- Yes --> D["🤖 Agent: ADVANCE → shipowner paid"]
D --> E{"Berthed at Cebu? (800 m, ≤ 0.5 kn × 3)"}
E -- Yes --> F["Debtor pays via Velo checkout"]
F --> G{"Webhook verified + amount == V?"}
G -- No --> H
G -- Yes --> I["🛑 Over-cap payout tried → Noir refuses (over_limit)"]
I --> J["🤖 Agent: SETTLE → LP, shipowner, treasury"]
J --> K["Escrow balance = 0"]
E -- "Due date + grace passed" --> L["⚠️ DEFAULT → revoke agent, sweep to treasury"]
| Stage | Trigger | Who acts | On-chain effect |
|---|---|---|---|
| 1. Tokenized | Shipowner submits the waybill | Treasury | registerDevice + registerAgent (cap 880 XLM) |
| 2. Funded | Investor commits capital | LP | fundEscrow 850 XLM |
| 3. Advanced | First AIS "underway" tick | 🤖 Agent decides ADVANCE | authorizePayment 850 → shipowner, then claim |
| 4. Berthed | Inside 800 m Cebu geofence at ≤ 0.5 kn for 3 ticks | 🤖 Agent signs attestation | Off-chain proof of delivery |
| 5. Paid | Verified Velo payment.succeeded webhook |
Treasury | fundEscrow 1,000 XLM |
| 🛑 Guardrail | Agent tries a single 1,000 XLM payout | Noir refuses | checkPayment → over_limit, no tx, no fee |
| 6. Settled | Both settle gates pass | 🤖 Agent decides SETTLE | 3× authorizePayment (LP 880, shipowner 115, treasury 5), each payee claims, escrow = 0 |
| Due date + grace passed, no payment | Ops | unlinkDevice (revoke agent + sweep escrow to treasury) |
- Capped on-chain. Every payment is checked by Noir's
agent_registry. A single payout above the cap is refused before any fee is paid. - Roles, not addresses. The agent names who gets paid. Code maps roles to stored wallets and recomputes every amount, so the model can never pay an arbitrary wallet or see a secret.
- Two gates to settle. A verified Velo webhook for the exact invoice amount, confirmed with Velo's payment status (
paid, expected asset), plus a signed berthing attestation. - Advance only once under way. The agent's
ADVANCEgate reads the AIS readings: no payout until the vessel is under way. Berthing is the same rule everywhere: the last 3 readings at the quay at ≤ 0.5 kn. - No double payouts. One payment in flight per agent, and webhooks are de-duplicated by delivery ID before any side effect. A payout interrupted half-way resumes from the escrow balance: it tells exactly which payouts already landed, and any balance it can't explain holds the invoice.
- No double pledging. A second
registerDevicefor the same waybill hash is rejected on-chain (spike S3). - Fail closed. Any mismatch becomes a
HOLD. On default, ops revokes the agent and sweeps the escrow back to treasury. - Known limit. Noir's policy caps each payment and its expiry, not the payee or the running total, so the agent key is kept server-side and code chooses payees by role. Per-invoice agent keys are on the roadmap.
- Clear about what's simulated. Real: Noir contracts on Testnet, every escrow, authorize and claim, the per-payment cap and the Velo webhook HMAC check. Simulated: AIS vessel positions, the fixed 1 XLM = ₱1,000 rate, and the debtor payment when no Velo key is set. Velo pays the debtor's payment to the project's receiver address; the treasury then funds the invoice escrow from its own Testnet wallet.
- Testnet prototype. Factoring is regulated in the Philippines, and invoice-backed products for investors may count as securities. Shipper, vessel and debtor are fictional. Not financial advice.
Why does the agent need a cap if code already checks the amounts?
Defense in depth. If the agent key leaks or the code has a bug, Noir's agent_registry still refuses any single payment above 880 XLM, before a fee is paid.
Can the AI send money to its own wallet?
No. The model only names roles (SHIPOWNER, LP, TREASURY). Code maps those to stored addresses and recomputes every amount. A mismatch becomes a HOLD.
What if the ship anchors offshore near Cebu? It doesn't count. Berthing requires being inside the 800 m geofence and at ≤ 0.5 knots for three readings in a row.
What if the cargo owner never pays?
After the due date plus grace, ops triggers DEFAULT: the agent is revoked and the escrow is swept back to treasury. In this MVP the investor bears the loss, and the UI says so.
What if Testnet is down during the demo? The server can switch to an in-memory version of the contracts. Every screen labels it "simulated".
graph TD
subgraph Clients
SO[Shipowner view] --> API
LP[Investor view] --> API
OPS[Ops panel / Run Demo] --> API
DEB[Debtor] --> VCO[Velo hosted checkout]
end
subgraph "apps/server (one Node process)"
API[API + SSE event stream] --> AG["Settlement agent: rules + optional LLM reason"]
AG --> EX["Executor: validate, gate, recompute, one call at a time"]
SIM[AIS simulator + berthing rule] --> AG
WH["/api/webhooks/velo"] --> API
VCO -- payment.succeeded --> WH
EX --> NS["NoirAgentClient (@noirx402/agent-sdk)"]
end
subgraph Stellar Testnet
NS --> DR[device_registry]
NS --> AR[agent_registry]
NS --> PE[payment_escrow]
end
API -. checkout sessions .-> VELO[Velo SDK]
| Category | Technology | Purpose |
|---|---|---|
| Chain | Stellar Testnet + @noirx402/agent-sdk 0.3.0 |
Device registry, agent policy, escrow, authorize, claim, revoke and sweep |
| Payments | @carts1024/velo-sdk 0.1.0-alpha.4 |
Debtor checkout sessions and signed webhooks (server only) |
| Server | Node 24 + TypeScript (tsx) |
API, webhook receiver, agent runtime, AIS simulator, SSE stream |
| Frontend | HTML / CSS / vanilla JavaScript | Landing page, role portal, voyage chart, decision stream, ops panel |
| Accounts | scrypt passwords, HttpOnly session cookies, Nodemailer (SMTP) | Sign-up, email verification, password reset, rate limits |
| Agent | Gemini API (REST) or @anthropic-ai/sdk 1.3.0 for Claude (optional) |
Decides PROCEED or HOLD on each permitted payout; amounts always come from code |
| Tests | Vitest | Math, decision validator, executor gates, guardrail, recovery |
SDK: @noirx402/agent-sdk 0.3.0 (pinned). The agent touches the chain only through this SDK, on the deployed Testnet contracts from the SDK's built-in TESTNET config. No custom deployments.
| Contract | Testnet ID |
|---|---|
device_registry |
CAC4KOLHDLDYDWBOKXNKRN5KVHO56PLOIFXDLTBUWGVN6GVDEB7FQHU5 |
agent_registry |
CCMZDSPTLX7IIJWCYEUM5DJUHOSOYSTHGK777S2TXZWEMC5ZZGPJ3EBV |
payment_escrow |
CC7EAW5FNJEDBS7THM5IT6XIOHO4AOYMLXT3KSZ3HWUIKEACTW7E5BFS |
All calls go through one wrapper, NoirAgentClient:
| Step | Method | Signer | Code |
|---|---|---|---|
| Asset (native XLM SAC) | Asset.native().contractId(Networks.TESTNET) |
none | client.ts#L10 |
| All writes | sdk.execute(signer, op) |
varies | client.ts#L77 |
| Register invoice as device | registerDevice |
treasury | client.ts#L83 |
| Set agent policy (cap, asset, expiry) | registerAgent |
treasury | client.ts#L87 |
| Fund escrow | fundEscrow |
LP, then treasury | client.ts#L99 |
| Pre-check | checkPayment |
none (read) | client.ts#L103 |
| Pay (pre-checked, returns the real refusal reason) | authorizePayment |
agent | client.ts#L120 |
| Collect | claim |
shipowner / LP / treasury | client.ts#L147 |
| Escrow balance | balanceOf |
none (read) | client.ts#L151 |
| Default: revoke agent + sweep | unlinkDevice |
treasury | client.ts#L160 |
Related code: the executor's execute, the over-limit runGuardrail, default recovery in recovery.ts, and a per-(device, agent) lock in mutex.ts so the agent never has two payments in flight.
SDK: @carts1024/velo-sdk 0.1.0-alpha.4, server side only.
| Feature | Code |
|---|---|
Debtor checkout session (velo.checkout.sessions.create, asset native, idempotency key per invoice) |
createCheckout, velo.ts#L44 |
Signed webhook verification (Velo.webhooks.verify, raw body, 300 s tolerance) |
verifyWebhook, velo.ts#L131 |
Payment status (velo.paymentIntents.retrieve): before any money moves, the intent must be paid in the expected asset; Velo's amount wins over the webhook body |
retrievePaymentStatus, velo.ts#L91, checked in webhooks.ts#L50 |
Webhook route POST /api/webhooks/velo |
app.ts#L147 |
De-dupe by x-velo-delivery, match amount to the invoice, then treasury funds escrow |
applyPayment, demo.ts#L633 |
Without VELO_API_KEY, checkout is simulated and labelled as simulated in the UI. Without VELO_WEBHOOK_SECRET, only self-signed simulated deliveries pass verification.
Every transaction below was made on Stellar Testnet through the Noir SDK by the same agent code the demo uses. The settle run was recorded 7 Nov 2026; the lifecycle and default runs on 6 Nov 2026 by scripts/lifecycle.ts and scripts/default-demo.ts. Full details are in docs/testnet-proof.md.
End-to-end demo run on the live site (7 Nov 2026): the investor's 880 XLM settlement claim on the Noir payment escrow, signed by the investor and confirmed on Stellar Testnet (ledger 5604688, status Successful): 2c0cb3dc…afdec.
Full loop, end to end (register → fund → advance → Velo payment → settle → claims)
Recorded 7 Nov 2026 with ▶ Run Demo (POST /api/run-demo) in Testnet mode, using the same code as the live site. Agent wallet: GAP6Z…P5YV.
| Step | Transaction |
|---|---|
Invoice registered (device_registry) |
056d4274…aca2 |
Agent policy, 880 XLM cap (agent_registry) |
d0dcb52b…5728 |
| Investor funds 850 XLM escrow | e3bac447…3bdc |
| 🤖 Agent ADVANCE: authorizes 850 XLM → shipowner | 8b8384d7…995c |
| Shipowner claims the advance | 84962bc6…901c |
| Treasury funds 1,000 XLM after the verified Velo webhook | 99d907da…a4f2 |
| 🤖 Agent SETTLE: authorizes 880 XLM → investor | d2d0c38b…388f |
| 🤖 Agent SETTLE: authorizes 115 XLM → shipowner | 08d9f63b…91c5 |
| 🤖 Agent SETTLE: authorizes 5 XLM → treasury | 83177fb2…b773 |
| Investor claims | 2ecab943…fe00 |
| Shipowner claims | 6ace8dae…5de1 |
| Treasury claims | de6a987b…f3a6 |
After the claims, balanceOf(invoice) is 0. In the same run, the agent's 1,000 XLM over-cap payout was refused by checkPayment with over_limit (contract error AgentNotAuthorized #3), with no transaction sent and no fee paid.
Earlier lifecycle run (register → fund → advance → claim)
| Step | Transaction |
|---|---|
Invoice registered (device_registry) |
9ba6b79c…7c5f |
Agent policy, 880 XLM cap (agent_registry) |
9bde0260…4faa |
| Investor funds 850 XLM escrow | 3d546679…9dd7 |
| Agent authorizes 850 XLM advance | d8899a5b…2385 |
| Shipowner claims the advance | 0c540e37…392c |
After the claim, the escrow balance is 0 and the shipowner is up +849.9989932 XLM (850 minus the claim fee).
Default recovery (revoke agent + sweep escrow to treasury)
| Step | Transaction |
|---|---|
| Invoice registered | 25d85019…7d |
| Agent policy, 880 XLM cap | 88482636…ff |
| Investor funds 850 XLM | ec5381b8…35 |
| Recovery tx 1 | eb14b8b4…6d |
| Recovery tx 2 | bef895a6…0b |
| Recovery tx 3 | b18ca2e2…a8 |
Escrow went from 850 to 0, and treasury was up +849.9978111 XLM. After revoke, checkPayment returns no_agent and the wrapper refuses to send.
Guardrail: an over-cap payout is refused by checkPayment with over_limit before any transaction or fee (spike S8 in docs/spikes.md).
noirxvelo/
├── apps/
│ ├── server/ # One Node process: API, Velo webhook, agent runtime, static frontend
│ │ └── src/
│ │ ├── index.ts # Long-running server entry (npm start)
│ │ ├── app.ts # HTTP routes, SSE stream, /api/webhooks/velo
│ │ ├── vercel.ts # Vercel function entry (same handler)
│ │ ├── demo.ts # Invoice state machine and Run Demo loop
│ │ ├── agent.ts # Decision policy (roles only) + optional LLM reason
│ │ ├── telemetry.ts # AIS simulator and Cebu berthing rule
│ │ ├── velo.ts # Velo checkout, payment status, webhook verification
│ │ ├── webhooks.ts # POST /api/webhooks/velo: verify, confirm status, de-dupe, route
│ │ ├── simchain.ts # In-memory contracts for labelled simulation mode
│ │ ├── site.ts # Website API: auth, portal, enquiry/newsletter routes
│ │ ├── accounts.ts # Accounts, sessions, verification, reset, rate limits
│ │ ├── portal.ts # Shared role portal ledger (shipowner, investor, cargo owner)
│ │ ├── portal-chain.ts # Portal invoices on Stellar Testnet: jobs, agent payouts, exact resume
│ │ ├── wallets.ts # Custodial Testnet wallets (AES-256-GCM), Friendbot top-ups, per-account lock
│ │ ├── kv.ts # Shared Redis store and locks (Vercel)
│ │ ├── db.ts # JSON store (data/sailo.json, git-ignored)
│ │ └── mailer.ts # SMTP email (logs links in development)
│ └── web/ # Static frontend (no build step)
│ ├── index.html # Sailo landing page + portal (site.js, portal.js)
│ ├── app/index.html # Live Testnet demo (/app)
│ └── assets/ # hero.jpg, voyage.jpg
├── packages/
│ ├── agent/ # NoirAgentClient, executor, guardrail, recovery, mutex
│ └── shared/ # Types, canonical waybill hash, payout math, seed data, store
├── scripts/
│ ├── provision.ts # Creates and funds Testnet wallets into .env.local
│ ├── lifecycle.ts # Full Noir lifecycle smoke test
│ ├── default-demo.ts # Default + recovery on Testnet
│ └── spikes/ # S2, S3, S8 live checks
├── docs/ # spikes.md, testnet-proof.md, worklog.md
├── PRD.md # Product requirements
├── .env.example
├── .nvmrc # Node 24.22.1
└── package.json # npm workspaces: apps/*, packages/*
You need: Node 24.22.1 (see .nvmrc; older Node silently installs the retired agent-sdk 0.2.0) and internet access to Stellar Testnet. No wallet extension is needed: provision creates and funds Testnet wallets with Friendbot.
git clone https://github.com/pdyntech/sailo.git
cd sailo
nvm use # Node 24.22.1
npm install # one install at the repo root (workspaces)
npm run provision # once: creates + funds Testnet wallets into .env.local
npm start # http://localhost:3000Optional: add VELO_API_KEY, VELO_WEBHOOK_SECRET and LLM_API_KEY to .env.local (see .env.example). Without them, checkout and webhooks run in a labelled simulated mode.
Open http://localhost:3000 for the landing page and portal ("Get started" creates an account; in development, email links show up in the UI and server log). For the Testnet loop, open http://localhost:3000/app and press ▶ Run Demo in the Ops panel. The whole loop runs on Stellar Testnet in about 90 seconds. Every step is also a manual button in the Shipowner, Investor and Debtor views.
Other commands:
npm test # unit tests (Vitest)
npm run lifecycle # full Noir lifecycle on Testnet, prints Stellar Expert links
npm run default-demo # default + recovery on Testnet
npm run check-mail -- you@example.com # checks SMTP_URL / MAIL_FROM in .env.local by sending a test emailDeploy: Vercel (vercel.json is included) with a Redis store: add Upstash from the Vercel Marketplace (Storage tab), which sets KV_REST_API_URL and KV_REST_API_TOKEN. Accounts, portal invoices and the demo run are then shared by every instance and survive restarts. Render or Railway also work: start command npm start, Node 24, and point DATA_DIR at a persistent disk (or add the same Redis variables). Then set the Velo webhook URL to https://<your-host>/api/webhooks/velo. Health check: GET /api/health. See apps/server/README.md.
| Name | What it is | Where to get it |
|---|---|---|
TREASURY_*, SHIPOWNER_*, LP_*, DEBTOR_*, AGENT_*, RELAYER_* (_PUBLIC, _SECRET) |
Testnet demo wallets | npm run provision |
VELO_API_KEY |
Velo Testnet API key (real checkout sessions) | velo-build.dev dashboard |
VELO_WEBHOOK_SECRET |
Verifies Velo webhooks | Velo dashboard |
VELO_CHECKOUT_ASSET |
Checkout asset, default native |
Optional |
APP_URL |
Public site URL for checkout success and cancel links | Hosting provider |
LLM_API_KEY, LLM_MODEL, LLM_PROVIDER |
Gemini or Claude API key for the agent's PROCEED/HOLD judgment. A Claude key (sk-ant-…) uses Claude, any other key (Google's AIza… or AQ.…) Gemini; LLM_PROVIDER=gemini|anthropic forces one. LLM_MODEL defaults to gemini-3.5-flash or claude-opus-5-5; when Gemini is rate-limited or overloaded the agent tries LLM_FALLBACK_MODEL (default gemini-3.5-flash-lite). Without a key the rules decide |
aistudio.google.com/apikey or platform.claude.com → API keys |
DATA_DIR |
Folder for accounts, sessions and portal invoices (sailo.json) |
A persistent disk on the host |
SMTP_URL, MAIL_FROM |
Outgoing email for verification and password reset. Without them a deployed site skips email verification and can't send password-reset links. Test them first with npm run check-mail |
Any SMTP provider (e.g. Resend, Gmail app password) |
NODE_ENV |
production hides development email links in the UI |
Hosting provider |
TRUST_PROXY |
1 trusts X-Forwarded-For (on by default in production) |
Optional |
PORTAL_VOYAGE_MS |
Portal voyage length, default 60000 (the advance's Testnet transactions run during the voyage) |
Optional |
KV_REST_API_URL, KV_REST_API_TOKEN (or UPSTASH_REDIS_REST_*, or REDIS_URL) |
Shared Redis store for accounts, portal invoices and the demo run. Required on Vercel | Upstash via the Vercel Marketplace |
WALLET_ENCRYPTION_KEY |
Encrypts the portal's custodial Testnet wallet keys. Defaults to a key derived from TREASURY_SECRET: keep that secret unchanged, or existing portal wallets can't be unlocked |
Optional |
PORTAL_ONCHAIN |
0 runs new portal invoices in memory (simulated) instead of on Stellar Testnet |
Optional |
OPS_TOKEN |
Lets the operator switch the live site between Testnet and simulation (open /app?ops=<token> once). Unset on a deployed server: switching is off |
Optional, recommended on deploy |
PORT |
Server port, default 3000 |
Optional |
DEMO_TICK_MS |
AIS tick interval, default 1800 |
Optional |
SIM_LATENCY_MS |
Fake network delay in simulation mode, default 450 |
Optional |
NOIRXVELO_DATA_FILE |
File for the demo invoice store; empty keeps it in memory | Optional |
LIVE |
1 runs the live Testnet tests in npm test |
Optional, tests only |
SIMULATE_CHAIN |
1 runs the contracts in memory, labelled "simulated". Turns on automatically when wallet keys are missing |
Optional |
Landing page: hero, invoice card and headline numbers.
Live Testnet demo, settled: see the screenshot in Testnet proof.
- Per-invoice agent keys (or a payee allow-list in the policy), so one leaked key can't touch other invoices.
- Live AIS feeds plus terminal discharge data, so delivery doesn't rest on AIS alone (it can be spoofed).
- PHP stablecoin settlement and an off-ramp, in place of testnet XLM at a demo rate.
- Investor pool contract so many LPs can fund many invoices.
- SEC pathway: financing company licence or regulatory sandbox.
| Member | GitHub | Discord | Lane |
|---|---|---|---|
| Helena | @helenaherrero515 | haenlenaeean |
Fullstack Developer and DevOps |
| Ethan | @thanreiz | perrytot_ |
Blockchain Developer |
| Dia Aviles | @krstndiane | kirs6103 |
Project manager & Frontend Developer |
Built on Noir agent contracts, Velo checkout and the Stellar Testnet.
Libraries
| Library | Used for |
|---|---|
@noirx402/agent-sdk 0.3.0 |
All Noir contract calls (register, policy, escrow, check, authorize, claim, unlink) |
@carts1024/velo-sdk 0.1.0-alpha.4 |
Checkout sessions and signed webhook verification |
@stellar/stellar-sdk 16.4.1 |
Keypairs, native XLM asset contract, Testnet config |
| Nodemailer | Verification and password-reset email |
@vercel/functions |
Vercel deployment of the API |
| tsx, esbuild, TypeScript, Vitest | Running, bundling, typing and testing |
@anthropic-ai/sdk 1.3.0 (optional) |
Claude's PROCEED/HOLD decision on each permitted payout, when a Claude key is set (Gemini is called over REST, no package) |
| Mermaid | Diagrams in this README |
Ideas and references: the Velo × Noir Builder Handbook, the Noir SDK examples (check-and-pay.ts, webhook relay) and the Velo Express / Next.js examples. Invoice factoring and AIS-based proof of delivery are standard trade-finance ideas, applied here to inter-island shipping.
© 2026 Sailo. Testnet prototype for the Velo × Noir Agentic Payment Hackathon. Fictional shipper, vessel and debtor. Not financial advice.
Sailo
Sail today. Get paid today. Settle to the last stroop. ⚓

