Light Dark
Connect With Us

Fexr provides automated compliance and verifiable governance for communities through its smart contract-powered, crowd-verified oracles.

Help Us Grow!

Rate us on Google Play
5.0
Rate us on App Store
5.0
Fexr Claude Skill

One prompt.
Full governance app.

Getting individual API endpoints from Claude is easy. Orchestrating wallet management, liquidity contracts, governance proposals, member roles, and on-chain execution into a working app is not. The Fexr Claude Skill handles that orchestration — using battle-tested APIs underneath.

Early access: The skill is actively being refined. Submit on the demo page to participate and help shape it.

Works in Claude.ai Production APIs DLT-compliant
claude — fexr-skill
You → Build a governance app — token-weighted voting, 90-day staking, auto-execute on quorum.
── Fexr Skill executing ─────────────
Member wallets provisioned (self-custody, DPoP-bound)
Staking contract deployed — 90-day lock, monthly cadence
Proposal → vote → quorum → execute pipeline wired
Webhooks registered, audit trail bound to DVI ledger
App ready. 7 API groups configured.
The Problem

Standalone APIs get you to step one. Orchestration gets you to production.

A governance app that manages wallets and liquidity isn't a single API call — it's eight interconnected systems that must fire in the right order, handle failure gracefully, and maintain a consistent security model throughout. You can read the docs. You can ask Claude to explain each endpoint. But sequencing them into a coherent application requires decisions that take months to get right on your own.

The Fexr Claude Skill encodes that sequencing. It knows which wallet call to make before creating a staking contract. It knows how to wire a governance vote result to an on-chain execution. It knows which auth scope each operation needs. You describe the governance model. It builds the app.

APIs under the hood
POST/wallets/createwallet provisioning
POST/staking/contractsliquidity lock
POST/governance/proposalsproposal creation
PUT/governance/proposals/{id}/votevote submission
POST/governance/proposals/{id}/executeon-chain execution
PUT/members/{id}/rolesrole assignment
POST/badges/mintbadge issuance
GET/clubs/{id}/liquidityliquidity state
POST/webhooks/registerevent subscriptions

The skill sequences these correctly. You don't have to.

The Skill in Action

Describe the governance model. Get the app.

The skill reads your natural-language description of how decisions should be made in your club — who proposes, who votes, what quorum means, what happens when it passes — and maps all of it to the Fexr API calls required to make it real. No boilerplate. No integration glue. A working app on production APIs from day one.

  • Self-custody wallets created per member, not per admin
  • Liquidity lock periods and distribution rules wired to contract
  • Proposal → vote → quorum → execute pipeline automated end to end
  • Auth, observability, and audit trail inherited automatically
Request to Participate
claude — fexr-skill
You → Build a governance app for my club. Members can propose treasury allocations, vote on them, and execute automatically when quorum is reached. Wallets should be self-custody. Liquidity locked for 90 days with monthly distributions.
── Fexr Skill ─────────────────────────
Provisioning member wallet schema (self-custody, DPoP-bound)
Creating staking contract — 90-day lock, monthly cadence
Wiring proposal creation → member notification → vote window
Setting quorum threshold (default 51%, configurable)
Binding quorum pass → on-chain execution endpoint
Registering webhooks for vote events and execution receipts
Generating audit trail bindings to DVI ledger
App ready. 7 API groups configured. Review at /governance/preview
What Gets Built

Everything a governance app needs.
Nothing it doesn't.

Wallet Management

Self-custody wallets created per member across Polygon, Solana, and Avalanche. Key management stays on-device. Multi-sig thresholds configurable per club role.

Liquidity Contracts

Staking contracts with configurable lock periods, distribution cadence, and exit conditions. Contract terms visible on-chain before any member commits.

Proposal & Voting UI

Create proposals, set vote windows, configure quorum thresholds. Members vote from the Fexr wallet. Results bind to execution automatically when quorum is met.

Member Roles & Permissions

Role hierarchy maps to API scopes. Proposers, voters, executors, and observers each get the minimum permissions required. Roles update on badge events.

On-Chain Execution Engine

When a vote passes quorum, the execution endpoint fires automatically. No manual trigger. Receipts log to the DVI ledger with a verifiable timestamp.

Audit Trail & Observability

Every proposal, vote, and execution is logged with a tamper-evident record. Export to your monitoring stack or surface in-app via the observability webhooks.

Why Not Just Ask Claude for the APIs?

You can. But you'll still need to solve this.

Asking Claude for APIs directly
  • Claude gives you the correct endpoint signatures — but not the call sequence. Wallet must exist before staking contract. Contract must settle before governance executes. One wrong order breaks state.
  • Auth scope for each operation is different. Mapping DPoP tokens, role-gated endpoints, and webhook signing keys manually takes days.
  • Error handling across 8+ API groups is improvised. A failed vote submission shouldn't leave a half-created proposal in an inconsistent state.
  • DLT compliance constraints — what can be promised, what must be disclosed — aren't encoded in generic API docs.
Using the Fexr Claude Skill
  • Call sequence is proven and encoded in the skill. Wallet → contract → governance wires up correctly the first time, every time.
  • Auth model is inherited. DPoP binding, role scopes, and webhook signatures are pre-configured per operation type.
  • Error handling follows the same retry and dead-letter pattern as the Fexr integration fabric — no improvised rollback logic.
  • Compliance framing is built in. The skill generates app copy and contract disclosures that align with Fexr's DLT license constraints.
How It Works

Three steps from prompt to production

1
Describe your governance model

Tell the skill how your club makes decisions: who proposes, who votes, what quorum means, how long votes stay open, and what happens when they pass. Plain language is fine.

2
The skill maps it to Fexr APIs

The skill translates your governance description into the correct API calls, in the correct order, with the correct auth scope and error handling for each operation.

3
Deploy against live APIs

Generated code targets Fexr production endpoints directly — not mocks. Request your API credentials via the developer portal and your governance app is live.

Underneath the Skill

The full integration fabric

The Fexr Claude Skill builds on top of the same API and webhook infrastructure available to all developers — DPoP auth, replay protection, rate limiting, observability, and auto-retry included. You can extend the generated app with any connector from the integration hub.

Ready to build your governance app?

The skill is in active development. Submit on the demo page to participate — help us find the edge cases and get early access before general availability.