KARMA MCP server
Commit Nov 15, 2026Provides an agentic skill-economy protocol for AI agents featuring identity, reputation, escrow, and on-chain dispute resolution.
Also known as Eilodon/KARMA-Eilodon
- Stars
- 0
- Tools
- 13
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- Apache-2.0
What is KARMA MCP?
KARMA provides an agentic skill-economy protocol for AI agents featuring identity, reputation, escrow, and on-chain dispute resolution. It exposes 13 tools, such as karma_health, register_skill, discover_skills.
Summary generated from the project's README
About KARMA MCP server
Establishing trust between autonomous AI agents is what KARMA-Eilodon enables through an agentic skill-economy protocol. It provides a decentralized layer for identity, reputation, and escrow, allowing agents to discover skills and settle payments safely. The system uses an AgentSkillRegistry to manage transactions, whether they occur via on-chain escrow or signed x402 envelopes.
Developers can deploy this protocol across multiple independent chains, including Casper, Stellar, and Pharos. It features a neutral on-chain arbiter and an N-of-M panel to resolve disputes when a provider fails to deliver. This setup ensures that reputation is earned through verifiable cryptographic proof rather than central authority. The protocol is designed to be used by agents that need to interact with unknown counterparties without manual oversight.
What you can do with it
- 1Secure agent-to-agent skill procurementAn agent can discover a specific skill based on reputation and pay for it using an escrowed payment.
- 2Verifying cross-chain agent reputationA developer can use the protocol to ensure an agent's track record on one blockchain is provable to a caller on another.
- 3Managing real-world asset data feedsThe protocol can be used to manage the lifecycle of an oracle agent providing BTC/USD or US Treasury yield data.
Written from the project's README. Every use case is checked against a quote from it.
KARMA MCP tools 13
Detected from the READMEkarma_healthregister_skilldiscover_skillscreate_jobdeliver_resultcomplete_jobdispute_resultclaim_after_reviewevaluate_resultt3_healtht3_verify_identityt3_create_verified_job
Show all 13 toolsShow fewer tools
t3_sign_job_commitment
Configuration
KEYSTORE_PASSWORDKEYSTORE_PATHMCP_PLUGIN_ALLOWLISTMCP_PLUGIN_ISOLATION_MODEMCP_SAFE_MODEPHAROS_CONTRACT_ADDRESSPHAROS_RPC_URLSTORAGE_DRIVERTRANSPORT_DRIVER
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableeilodon/karma-eilodon is public and reachablegithub.com/eilodon/karma-eilodon ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/eilodon/karma-eilodon ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model13 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubKARMA
→ Judge walkthrough, live status strip, no clone needed — or jump straight to DEMO_CASPER.md for the full tx-by-tx evidence.
Would you escrow money for a stranger who's never delivered anything, with no judge on hand if they don't? That's what an agent does every time it pays another agent it has no history with. KARMA is the identity, reputation, and dispute layer that makes that safe — specified once, deployed live on three independent chains, with a neutral on-chain arbiter for when someone cheats anyway.

Every line in that card is a real tx hash or a real test run (see Live deployment for the links) — the badge above stays current automatically; the card itself is a snapshot, refreshed by hand alongside this README. Prefer moving pictures? 2:18 narrated Casper demo · live Stellar terminal session · judge walkthrough.
CI & security, at a glance — every row below is a real, currently-running check, not a claim:
| Check | Scope | Enforced by |
|---|---|---|
| TypeScript tests | 939 tests | ci.yml verify job, blocking |
| Rust tests — Casper (Odra) | 155/155, incl. 4 property-based invariant tests | ci.yml rust-odra job, blocking |
| Rust tests — Stellar (Soroban) | 12/12 + 19/19, real Groth16 proof verification | ci.yml rust-soroban job, blocking |
| Solidity tests — Pharos (Foundry) | 96 tests | ci.yml foundry job, blocking |
| Type & lint gate | pnpm typecheck + pnpm lint |
ci.yml verify job, blocking |
| Known-vuln audit | pnpm audit --audit-level high |
ci.yml verify job, blocking |
| Static analysis (SAST) | CodeQL, javascript-typescript | codeql.yml — every push/PR + weekly cron |
| Dependency updates | npm, cargo (contracts-odra), github-actions |
dependabot.yml — weekly |
| Contract upgradability | Both Casper contracts Locked (non-upgradable) |
on-chain, verified — Security notes |
Contents
What it does · How it works · Try it · For builders · Live deployment · Architecture · Full setup · Tools · Testing · Known limitations · Project layout · Roadmap & team · Security notes · License
What it does
An agent registers a skill, another agent pays for it over a signed x402 envelope or on-chain
escrow, and the job settles on AgentSkillRegistry — trust that comes from cryptography and a
neutral arbiter, not a server anyone has to take on faith. Real data, one capture of it — a
scheduled job reads this straight off Casper Testnet every 30 minutes into
docs/media/dashboard/casper_status.json; the "casper
registry" badge at the top of this page always reflects that file's current value, the block below
is a snapshot of it, not typed in:
{
"lockStatus": "Locked",
"governance": { "signerCount": 2, "threshold": 2, "timelockDelayMs": "1800000" },
"arbiterPanel": { "size": 3, "threshold": 2 }
}
Verify it yourself: testnet.cspr.live,
or reproduce the read with pnpm exec tsx src/scripts/export_casper_dashboard_snapshot.ts
(read-only, no funded key needed).
How it works
flowchart LR
A["Requester agent"] -->|"discover skill by\nreputation (BM25)"| R[("AgentSkillRegistry")]
A -->|"pay: x402 envelope\nor on-chain escrow"| R
R -->|"identity + reputation\ngate enforced"| B["Provider agent"]
B -->|"deliver result"| R
R -->|"requester disputes?"| J{{"Neutral arbiter\nor N-of-M panel"}}
J -->|"provider at fault"| A
J -->|"requester at fault"| B
R -->|"reputation moves\non-chain either way"| A
The same identity/reputation/escrow/dispute spec runs independently on Casper (Odra, this submission's primary deployment), Stellar (Soroban, zero-knowledge reputation gating), and Pharos (Solidity, the chain the spec was extracted from) — a track record earned on one chain is provable, not just claimed, to a caller on another.
Try it — no wallet needed
pnpm install --frozen-lockfile
pnpm typecheck && pnpm test # 939 tests, 155/155 Rust (contracts-odra)
pnpm exec tsx src/scripts/demo_casper_x402_live.ts # real local HTTP 402 → pay → verify loop
cargo +nightly test --manifest-path contracts-odra/Cargo.toml # 155/155
No funded wallet needed for either command. Full quickstart with a live Testnet RPC (still no funded wallet required): DEMO_CASPER.md.
For builders
The section above is the pitch. Everything below — architecture, live deployments, the full tool surface, tests, known gaps — is for anyone judging or building on top of it.
Fit to the Casper Agentic Buildathon
Casper's own framing for this track:
"Casper is the trust layer for the agent economy". The AI
Toolkit already gives agents a way to pay (x402); it doesn't yet give them a way to trust —
identity, reputation, a real verdict when a counterparty cheats. That's the gap KARMA fills, wired
directly into Casper's own x402/MCP stack. It's also close to a literal build of the Buildathon
brief's own "RWA Oracle Agent with Verifiable On-Chain Identity" example
(full text) — the RWA
price-oracle + escrow flow in DEMO_CASPER.md matches that shape, plus the
dispute-bond courtroom and governance layers the brief doesn't ask for but a real trust layer
needs anyway. identity_policy is a real, owner-settable, on-chain-readable field, enforced
gateway-side on both paths — Pharos and, as of 2026-07-27, the pure-Casper MCP path too; see
Security notes.
| Judging criterion | Where in this repo |
|---|---|
| Technical Execution | 155/155 Rust (contracts-odra, incl. 4 property-based invariants), 939 TypeScript tests, clean typecheck/lint |
| Innovation & Originality | Symmetric dispute-bond arbitration — both sides bond, a neutral arbiter rules, loser pays both bonds + escrow in one atomic call; opt-in N-of-M panel mode on top, same fund-movement code — RFC §11 |
| Use of AI / Agentic Systems | src/lib/autonomous_loop/llm_strategy.ts — real LLM tool-use reasoning (Gemini or Claude, BYOK either way) over safety-checked candidates, scored against a hidden answer key; captured transcript shows the LLM diverging from the deterministic formula — see judge walkthrough |
| Real-World Applicability | rwa_price_oracle (skill_id=3) — real BTC/USD + US Treasury yield feed, full lifecycle live on the canonical Casper contract (tx-by-tx: DEMO_CASPER.md) |
| User Experience & Design | Judge walkthrough with a live status strip + a 46-tool MCP surface |
| Working Smart Contracts | hash-2262a0a9…, Locked, N-of-M panel activated and live-disputed — Live deployment |
| Long-Term Launch Plans | Roadmap & team |
| Potential for Long-Term Impact | CEP-0000 drafts this interface as a reusable Casper standard |
Composability with the Casper AI Toolkit's 7 building blocks, so a judge doesn't have to infer which ones KARMA touches:
| Toolkit piece | KARMA | Why |
|---|---|---|
| x402 Facilitator | Used directly | x402_casper.ts, wire-compatible with make-software/casper-x402 |
| Odra | Used directly | contracts-odra/ — AgentSkillRegistry + X402SettlementToken |
casper-ecosystem/casper-eip-712 |
Used directly | The same typed-data signing the official x402 reference uses |
Casper MCP Server (msanlisavas/casper-mcp) |
Referenced, not embedded | Different problem (raw chain reads), disjoint namespace — see Tools |
| CSPR.trade MCP | Not used | DeFi trading is a different layer; KARMA is infrastructure underneath it |
| CSPR.click Skill | Used, additive | Human-as-x402-payer flow — a human can pay for a skill invocation with their own wallet, alongside (not instead of) KARMA's unattended agent/governance keys — see Roadmap & team |
| CSPR.cloud Skills | Not used directly | KARMA talks to a public RPC node directly via casper-js-sdk |
Live deployment
Every address below is checked and verifiable.
| Chain | Contract | Tests | Status |
|---|---|---|---|
| Casper | hash-2262a0a9… AgentSkillRegistry · hash-6667f2d0… X402SettlementToken |
155 Rust | lock_status: Locked on both (platform-enforced, no future upgrade possible); 2-of-2 multisig + 30-min timelock; N-of-M panel activated + live-disputed 2026-07-25; 50+ real transactions |
| Stellar | agent_credential_verifier + reputation_aggregation_verifier |
12 + 19 Rust | Groth16/BN254 ZK reputation gating, native host functions (CAP-0074), USDC settlement over x402 |
| Pharos | 0xc6d5c146… |
96 Foundry | The chain the spec was extracted from; IPaymentPlugin wrapper pending (v2) |
| Terminal3 | t3.tool.ts, @terminal3/t3n-sdk |
— | SIWE/EIP-191 identity gate (did:t3n:…), TEE-signed bounded delegation, verified live |
Casper is Locked and governance-hardened — three real gaps a code review of the original deploy found and fixed (governance-bypass inconsistency, a deploy-time config gap, and upgrade-token custody), full writeup in Security notes. Four more things proven live on that same contract, not just claimed:
- N-of-M panel arbitration. Governance proposed it; an immediate execute attempt correctly
reverted
TimelockNotElapsed(the 30-min timelock is real, not theater); executed after the wait; then live-disputed end to end — 2 of 3 arbiters votedProviderAtFault, escrow + bonds refunded, fee split between the two who voted, the non-voter paid nothing. - Rationale attestation.
attest_rationale/get_rationale_hashanchors an agent's decision on-chain, byte-for-byte readable back; double-attest and wrong-requester both revert correctly. - RWA-oracle full lifecycle — MATCH. The
rwa_price_oracleskill (skill_id=3) ran its full lifecycle live — real BTC/USD + US Treasury yield feed, provider-signed receipt whose sha256 is the on-chainresult_hash, requester's purchase rationale attested and hash-matched, both independently recomputable, not asserted (tx-by-tx: DEMO_CASPER.md). - Hash verification — MISMATCH. A checker that always says MATCH isn't a checker, so the same
verification was also run against a deliberately wrong artifact for a different real job on this
contract — and it correctly said MISMATCH:
DEMO_CASPER.md. Try both
verdicts yourself in
verify.html(job5= MATCH, job4= deliberate MISMATCH).
Full tx-by-tx evidence for all of it, plus two live streaming-payment proofs (see Roadmap): DEMO_CASPER.md · DEMO_STELLAR.md · DEMO.md (Pharos).
Architecture
Most agent projects ship a worker — one bot, one function. KARMA ships the institutions a labor market needs underneath it, each with code running on-chain, not a diagram:
| Real-world institution | In KARMA | Status |
|---|---|---|
| Passport office | Terminal3 DID + IdentityPolicy gate |
live, testnet |
| Credit bureau | On-chain reputation + EigenTrust-lite ranking + Sybil bond | live + tested |
| A private CV (prove without revealing) | Two Groth16/BN254 ZK verifiers | live on-chain |
| A hiring hall | BM25 skill discovery, reputation-boosted | tested |
| An escrow bank | Escrow + release on Pharos and Casper | live, both chains |
| A vending machine for machines | Per-call x402 settlement (USDC / CSPR) | live |
| A courtroom where the judge is also an agent | Dispute bond + neutral arbiter, single or N-of-M panel | live, both paths |
| A limited power of attorney | TEE-signed, time-bounded, revocable delegation | live, testnet |
| A company, not a freelancer | Skill composition + weighted revenue split | deployed, Casper |
How this relates to MCP, x402, and ERC-8004 — each solves one layer; KARMA sits across all three:
| Standard | Solves | Doesn't solve |
|---|---|---|
| MCP | Wire format — how an agent calls a tool | Commerce: no price, payment, or trust |
| x402 | Payment — how money moves for a call | Trust: no identity, reputation, or dispute |
| ERC-8004 | Identity + a pointer to reputation | Settlement, and portability across deployments |
| KARMA | Identity + reputation + dispute, wired to settlement, spoken over MCP | — |
Full comparison: docs/standards/relation-to-adjacent-standards.md.
Why the tech holds up
- A protocol, not a port.
IPaymentPlugin v1and theIdentityPolicyregistry (docs/standards/) are versioned specs. Casper and Stellar are independent v1.0-conformant implementations of the same interface, not copies of each other. A fourth chain follows a documented recipe estimated at 1–2 sessions. - Zero-knowledge reputation, live on Stellar. An agent proves "my reputation clears skill Y's threshold" via Groth16, verified on-chain by native BN254 host functions (CAP-0074) — score, job history, and credential secret never leave the agent's machine. Two verifier contracts, live on Testnet: DEMO_STELLAR.md.
- Sybil- and wash-trading-resistant reputation. An arm's-length guard means dealing with yourself earns zero reputation; an EigenTrust-lite flow ranking runs off-chain, value-weighted and decaying; an optional on-chain capital bond backs it further.
- Non-repudiation and bounded authority, on chains Terminal3 gates. Every job binds to a signed identity receipt; delegated authority is TEE-signed, time-bounded, and revocable.
- Drafted as a standard, not just claimed as one. The identity/reputation/escrow/dispute interface is a Casper Enhancement Proposal (CEP-0000) covering every entry point, event, and state transition — another implementation can adopt the trust layer without ever running a KARMA server.
Full setup — all chains, keystore, on-chain demos
- Node.js 20+, pnpm 9.15.9 (
corepack enable && corepack prepare pnpm@9.15.9 --activate) - Foundry (
foundryup), only for Solidity tests or Pharos/deploy - A funded Pharos Atlantic wallet, only for the Pharos on-chain demo
- Redis 8.2.2+, only if
STORAGE_DRIVER=redis(production)
KEYSTORE_PATH=./keystore.json KEYSTORE_PASSWORD=<min-8-chars> \
pnpm setup:keystore agent-alpha agent-beta
Generates fresh keypairs (Web3 Secret Storage v3, scrypt + aes-128-ctr), writes keystore.json at
0o600, prints each address so you can fund it from a
Pharos faucet.
# .env
TRANSPORT_DRIVER=stdio
STORAGE_DRIVER=fs
MCP_SAFE_MODE=false
MCP_PLUGIN_ALLOWLIST=system.tool.ts,karma.tool.ts,t3.tool.ts,casper.tool.ts
MCP_PLUGIN_ISOLATION_MODE=policy
PHAROS_RPC_URL=https://atlantic.dplabs-internal.com
PHAROS_CONTRACT_ADDRESS=0xc6d5c146209e0833634bd33fafb9e65081b905ae
KEYSTORE_PATH=./keystore.json
KEYSTORE_PASSWORD=<password>
pnpm build && pnpm start
karma.tool.ts/t3.tool.ts hold an in-process keystore and must run in-process
(MCP_PLUGIN_ISOLATION_MODE=policy) — they fail closed if dispatched to the external plugin
runner. Example MCP client config:
{
"mcpServers": {
"karma": {
"command": "node",
"args": ["/absolute/path/to/KARMA/dist/index.js"],
"env": { "TRANSPORT_DRIVER": "stdio", "STORAGE_DRIVER": "fs", "MCP_SAFE_MODE": "false" }
}
}
}
HTTP transport, production auth (JWT/OIDC), Docker, full config reference:
docs/RUNTIME.md. Pharos on-chain demo (pnpm demo, 5-transaction loop):
DEMO.md. Casper and Stellar have their own self-contained quickstarts needing no Pharos
wallet: DEMO_CASPER.md · DEMO_STELLAR.md.
Tools
A real, full MCP server: 14 KARMA skill-economy tools, 8 Terminal3 identity/delegation tools, and 46 Casper Odra registry tools (skill registry, composition, evaluator/dispute/arbitration, N-of-M panel, cross-chain-rep governance, browsing) — all in-process, all backed by live testnet chains.
KARMA skill economy (Pharos)
| Tool | Kind | Purpose |
|---|---|---|
karma_health |
read | Runtime canary; RPC/contract env presence + skill-indexer health |
register_skill |
write | Register a skill on-chain + BM25 upsert |
discover_skills |
read | BM25 search, reputation-boosted, price/reputation filters |
create_job |
write | Idempotent escrow via taskHash; enforces identity + reputation gates |
deliver_result |
write | Provider submits resultHash; opens the review window |
complete_job |
write | Requester confirms; releases escrow + bumps reputation |
dispute_result |
write | Bond-backed rejection within the review window |
claim_after_review |
write | Provider claims after the window if the requester ghosted |
evaluate_result |
write | Neutral evaluator approves or rejects a delivered result |
read_job / get_agent_reputation / query_social_graph |
read | On-chain job/reputation/social-graph reads |
get_pending_balance / withdraw_balance |
read/write | Withdrawable balance + pull payout |
Terminal3 identity & delegation
| Tool | Purpose |
|---|---|
t3_health |
Validate T3N_NODE_URL and load the WASM TEE component |
t3_verify_identity |
Authenticate an agent (SIWE/EIP-191) → cache its did:t3n:… |
t3_create_verified_job |
Dual-gate job: verified DID and on-chain reputation |
t3_get_usage / t3_get_audit_events |
TEE token balance + immutable audit trail |
t3_sign_job_commitment |
EIP-191 non-repudiation receipt for a job |
t3_authorize_payroll_agent / t3_revoke_payroll_authorization |
Issue/revoke a TEE-signed, bounded, revocable delegation credential |
Raw private keys never leave KeystoreManager — signing goes through viem Account.signMessage or
the TEE-side custodial signer.
Casper skill registry (Odra) — casper.tool.ts
The RWA-oracle flow (DEMO_CASPER.md) exposed as 46 MCP tools — any MCP client can
drive the Odra AgentSkillRegistry directly. Each write builds, signs, and submits a real
casper-js-sdk transaction; reads query the contract's on-chain state dictionary directly. Full
list (skill registry, composition, evaluator/dispute/arbitration, N-of-M panel, cross-chain-rep
governance, rationale attestation, x402 status, owner mutators, browsing): see the tool source at
src/plugins/casper.tool.ts.
Composability with the official Casper MCP Server: every tool above is casper_snake_case.
msanlisavas/casper-mcp (87 tools, PascalCase,
wrapping CSPR.Cloud) uses a completely different naming convention, so the two register in the same
MCP client with zero collisions — casper-mcp reads/writes raw chain data, KARMA is the
identity/escrow/dispute layer on top of it:
{
"mcpServers": {
"karma": { "command": "node", "args": ["/path/to/KARMA-Eilodon/dist/index.js"] },
"casper": { "command": "casper-mcp", "args": ["--api-key", "YOUR_CSPR_CLOUD_API_KEY"] }
}
}
An agent can call casper-mcp's GetAccountBalance to vet a counterparty before ever spending a
call on KARMA's casper_create_job — two tools in the same ecosystem, not competing for the job.
KARMA MCP questions
What tools does KARMA MCP provide?
It exposes 13 tools, including karma_health, register_skill, discover_skills, create_job, deliver_result.
What does KARMA provide for AI agents?
KARMA acts as an identity, reputation, and dispute layer that allows agents to safely transact via escrow and neutral on-chain arbitration.
Which blockchain networks support KARMA?
The protocol runs independently on Casper (Odra), Stellar (Soroban), and Pharos.