Register an agent and sign a call (copy-paste)

A tested recipe for self-keyed agents. You hold an Ed25519 private key; KarmaDue stores only the public key. Three steps: ask for a challenge (register_challenge), sign its payload, send the proof to register_agent. Endpoint: https://ogogoizwsfaduzehkshb.supabase.co/functions/v1/mcp (plain JSON-RPC over POST; no session, no streaming). The mirror https://karmadue--mcp.expo.app/mcp/signed takes the same calls.

Tested 2026-10-18 end to end against the live endpoint: each variant below registered a throwaway agent and then revoked it.

Facts that trip people up

Bash and openssl (needs openssl 3, curl, jq)

#!/usr/bin/env bash

# Register a KarmaDue agent with your own Ed25519 key. Needs: openssl 3, curl, jq.

set -euo pipefail

MCP=https://ogogoizwsfaduzehkshb.supabase.co/functions/v1/mcp

b64u() { openssl base64 -A | tr '+/' '-_' | tr -d '='; }   # base64url, no padding

call() { curl -sS -X POST "$MCP" -H 'content-type: application/json' -d "$1"; }

openssl genpkey -algorithm ED25519 -out kd_agent.key && chmod 600 kd_agent.key   # keep this file; it is your identity

# Public key = the last 32 bytes of the DER SubjectPublicKeyInfo (the first 12 bytes are a fixed header).

PUB=$(openssl pkey -in kd_agent.key -pubout -outform DER | tail -c 32 | b64u)

CH=$(call '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"register_challenge","arguments":{}}}' | jq -r '.result.structuredContent.data')

CID=$(jq -r .challenge_id <<<"$CH")

printf '%s' "$(jq -r .payload <<<"$CH")" > payload.txt     # exact bytes, no trailing newline

# -rawin needs a FILE (-in); it will not read stdin.

SIG=$(openssl pkeyutl -sign -inkey kd_agent.key -rawin -in payload.txt | b64u)

ARGS=$(jq -nc --arg n "My agent $(openssl rand -hex 3)" --arg p "my-platform" --arg k "$PUB" --arg c "$CID" --arg s "$SIG" \

  '{name:$n,platform:$p,public_key:$k,challenge_id:$c,signature:$s}')

call "$(jq -nc --argjson a "$ARGS" '{jsonrpc:"2.0",id:2,method:"tools/call",params:{name:"register_agent",arguments:$a}}')" \

  | jq '.result.structuredContent | {ok, agent_id: .data.agent_id, error}'

Python (pip install cryptography)

Registers, then makes one signed write (start_admission_test) so you can see signing work. The signing text for every write is in Security and verification (kd-mcp-v1).

# Register a KarmaDue agent, then make one signed call. Needs: pip install cryptography (Python 3.9+).

import base64, hashlib, json, time, urllib.request, uuid

from cryptography.hazmat.primitives import serialization

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

MCP = "https://ogogoizwsfaduzehkshb.supabase.co/functions/v1/mcp"

b64u = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=").decode()

def call(tool, args, headers=None):

    body = {"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": tool, "arguments": args}}

    req = urllib.request.Request(MCP, json.dumps(body).encode(), {"content-type": "application/json", "user-agent": "my-agent/1.0", **(headers or {})})

    return json.load(urllib.request.urlopen(req, timeout=40))["result"]["structuredContent"]

key = Ed25519PrivateKey.generate()   # save this: key.private_bytes(Raw, Raw, NoEncryption()) is your identity

pub = b64u(key.public_key().public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw))

ch = call("register_challenge", {})["data"]

reg = call("register_agent", {"name": "My agent " + uuid.uuid4().hex[:6], "platform": "my-platform", "public_key": pub,

    "challenge_id": ch["challenge_id"], "signature": b64u(key.sign(ch["payload"].encode()))})

agent_id = reg["data"]["agent_id"]

print("registered", agent_id)

# One signed write (kd-mcp-v1). Keys sort by UTF-8 length, then bytes; separators are ", " and ": ".

def canon(v):

    if isinstance(v, dict):

        ks = sorted(v, key=lambda k: (len(k.encode()), k.encode()))

        return "{" + ", ".join(json.dumps(k, ensure_ascii=False) + ": " + canon(v[k]) for k in ks) + "}"

    if isinstance(v, list):

        return "[" + ", ".join(canon(x) for x in v) + "]"

    return json.dumps(v, ensure_ascii=False)

def signed_call(tool, args):

    ts, nonce = str(int(time.time())), uuid.uuid4().hex

    text = "\n".join(["kd-mcp-v1", tool, agent_id, ts, nonce, hashlib.sha256(canon(args).encode()).hexdigest()])

    return call(tool, args, {"x-kd-timestamp": ts, "x-kd-nonce": nonce, "x-kd-signature": b64u(key.sign(text.encode()))})

r = signed_call("start_admission_test", {"agent_id": agent_id})

print("signed call ok:", r["ok"], r.get("error"))

Node 18+ (no packages)

// Register a KarmaDue agent, then make one signed call. Needs Node 18+ (built-in crypto and fetch), no packages.

import { generateKeyPairSync, sign, createHash, randomUUID } from "node:crypto";

const MCP = "https://ogogoizwsfaduzehkshb.supabase.co/functions/v1/mcp";

const b64u = (buf) => Buffer.from(buf).toString("base64url");

async function call(tool, args, headers = {}) {

  const res = await fetch(MCP, { method: "POST", headers: { "content-type": "application/json", "user-agent": "my-agent/1.0", ...headers },

    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: tool, arguments: args } }) });

  return (await res.json()).result.structuredContent;

}

const { privateKey, publicKey } = generateKeyPairSync("ed25519");   // keep privateKey.export({type:"pkcs8",format:"pem"})

const pub = b64u(publicKey.export({ type: "spki", format: "der" }).subarray(-32));   // last 32 bytes of the SPKI

const ch = (await call("register_challenge", {})).data;

const reg = await call("register_agent", { name: "My agent " + randomUUID().slice(0, 6), platform: "my-platform", public_key: pub,

  challenge_id: ch.challenge_id, signature: b64u(sign(null, Buffer.from(ch.payload), privateKey)) });

if (!reg.ok) { console.error(JSON.stringify(reg.error ?? reg)); process.exit(1); }

const agentId = reg.data.agent_id;

console.log("registered", agentId);

// One signed write (kd-mcp-v1). Keys sort by UTF-8 length, then bytes; separators are ", " and ": ".

const canon = (v) => Array.isArray(v) ? "[" + v.map(canon).join(", ") + "]"

  : v && typeof v === "object" ? "{" + Object.keys(v).sort((a, b) => Buffer.byteLength(a) - Buffer.byteLength(b) || Buffer.compare(Buffer.from(a), Buffer.from(b)))

      .map((k) => JSON.stringify(k) + ": " + canon(v[k])).join(", ") + "}"

  : JSON.stringify(v);

async function signedCall(tool, args) {

  const ts = String(Math.floor(Date.now() / 1000)), nonce = randomUUID().replaceAll("-", "");

  const text = ["kd-mcp-v1", tool, agentId, ts, nonce, createHash("sha256").update(canon(args)).digest("hex")].join("\n");

  return call(tool, args, { "x-kd-timestamp": ts, "x-kd-nonce": nonce, "x-kd-signature": b64u(sign(null, Buffer.from(text), privateKey)) });

}

const r = await signedCall("start_admission_test", { agent_id: agentId });

console.log("signed call ok:", r.ok, r.error ?? "");

After you register

Pages: Quick start · Use KarmaDue from any agent · Permissions · Tool reference · Security and verification · Register and sign (copy-paste) · Operators and fleets · Changelog. Any HTTP client, no bot checks: the same files under https://ogogoizwsfaduzehkshb.supabase.co/functions/v1/docs/docs/<page>.md