DEV Community: Fyrnity

Ghost Signature: Cryptographic Receipts for AI Output (Ed25519 + JWKS)

Anton Fredriksson — Tue, 12 May 2026 08:05:12 +0000

TL;DR

I built a tiny API that lets your AI agent cryptographically sign every output with Ed25519, so anyone can verify "yes, this came from agent X at time Y, unmodified" — without trusting you, me, or any platform. Public verify endpoint, free 20 signs/month, no SDK. Try it on RapidAPI.

The "did AI write this?" arms race is the wrong question

Every week another startup launches an "AI detector". Every week another paper shows they're 60% accurate at best, and they flag human writing as AI all the time.

The whole approach is backwards. You can't reliably reverse-engineer authorship from text alone — the signal just isn't there once the words are on the page.

But you can solve the inverse: let the author prove authorship at the moment of generation. That's what cryptographic signatures have done for code (sigstore), for emails (DKIM), for software updates (Ed25519 everywhere) for years.

So I built it for AI output.

Ghost Signature

Three endpoints. That's the whole API.

POST /sign → sign a piece of content (private, your key)
GET /verify → verify a signature (public, anyone)
GET /jwks → published public keys (rotation-aware)

Your agent signs at generation time. Anyone — recipient, journalist, fact-checker, downstream model — hits /verify and gets a yes/no with the signing agent's ID and timestamp. No login required to verify.

Signing in 2 lines

import requests

sig = requests.post(
    "https://ghostsignature.p.rapidapi.com/sign",
    headers={"X-RapidAPI-Key": "YOUR_KEY"},
    json={"agent_id": "research-bot-1", "content": output_text}
).json()

# attach sig["signature"] + sig["kid"] to your output

Response:

{
  "agent_id": "research-bot-1",
  "kid": "rb1-2026-05",
  "signature": "MEUCIQDx...",
  "signed_at": "2026-05-12T08:14:00Z",
  "alg": "Ed25519"
}

Attach the three fields to your message — in metadata, a footer, an HTTP header, wherever.

Verifying from anywhere (no auth)

curl "https://ghostsignature.p.rapidapi.com/verify?\
agent_id=research-bot-1&\
kid=rb1-2026-05&\
signature=MEUCIQDx...&\
content=..."

Response:

{
  "valid": true,
  "agent_id": "research-bot-1",
  "signed_at": "2026-05-12T08:14:00Z",
  "revoked": false
}

If anyone changed a single character → valid: false. If you rotated keys and revoked the old one → revoked: true with the original signing time still intact (soft revocation — old signatures stay verifiable as historical, just flagged).

Why Ed25519 + JWKS + soft revocation

Ed25519 — fast, small signatures (64 bytes), no parameter footguns like ECDSA. Same scheme SSH and Signal use.
JWKS with kid — your agent can rotate keys monthly without breaking old signatures. Each signature carries the kid that signed it; verifier looks up the right public key automatically.
Soft revocation — when a key is compromised, you mark it revoked but old signatures still verify as historical. You don't lose the audit trail; you just flag everything signed after the suspected breach.

What it's actually good for

AI-generated journalism / reports — readers can verify "this paragraph came from our verified research agent, not edited"
Agent-to-agent trust — downstream agent verifies upstream agent's output before acting on it
Audit logs — sign every decision your agent makes, keep an immutable provenance trail
Disclosure compliance — EU AI Act + similar regs are heading toward "label AI output". A signature is the strongest possible label.

It does not stop someone from copy-pasting your text and removing the signature. That's the point — absence of signature means "unverified", presence means "provably from this agent". Same trust model as PGP-signed emails.

Pricing

Free — 20 signs/month (verify is always free + public)
PRO — $29/month, 50,000 signs
ULTRA — $99/month, 250,000 signs

All hard-limited. No surprise bills.

Try Ghost Signature on RapidAPI

Built solo as part of a 5-API micro-SaaS family (fyrnity.com/tools). Feedback welcome — especially from people running agents in production who've thought about provenance.

ResonanceEngine — Score how well two texts resonate (semantic, intent, emotion, brand)

Anton Fredriksson — Tue, 21 Apr 2026 18:53:12 +0000

Stop shipping AI features blind. ResonanceEngine tells you exactly how well two texts resonate — whether that's a model output vs. expected answer, a chatbot reply vs. brand voice, or a generated email vs. the user's intent.

Why developers use it

LLMs are non-deterministic. You need a fast, calibrated way to measure "did the output actually match what we wanted?" — without hand-grading every response.

ResonanceEngine gives you a 0–100 score plus aligned/misaligned signals, in four modes:

🧠 Semantic — do the texts mean the same thing?
🎯 Intent — does the response fulfill the user's actual goal?
❤️ Emotional — does the tone match (warm, urgent, calm)?
🎨 Brand — does it sound like your brand voice?

Use cases

QA on AI responses — flag low-scoring outputs before they ship
Prompt evaluation — A/B test prompts with objective scoring
Content guardrails — block off-brand or off-intent generations
Chatbot evals — measure response quality at scale
RAG validation — does the answer actually match the retrieved context?

Quick start

curl -X POST 'https://resonance-engine.p.rapidapi.com/resonance-engine-evaluate' \
  -H 'x-rapidapi-key: YOUR_KEY' \
  -H 'x-rapidapi-host: resonance-engine.p.rapidapi.com' \
  -H 'Content-Type: application/json' \
  -d '{
    "source": "I need help fast, my server is down",
    "target": "Sure! Here is a 12-step guide to server architecture",
    "mode": "intent"
  }'

Response: Low intent score — the reply doesn't match the urgency.

Batch mode

Need to score 20 pairs at once? Use /resonance-engine-batch — same auth, takes an array of pairs and returns per-pair scores plus an average.

Pricing

Basic — $9/month, 5,000 evaluations
Pro — $29/month, 50,000 evaluations ⭐ recommended
Ultra — $99/month, 500,000 evaluations

Get ResonanceEngine on RapidAPI →

Stop Runaway AI Agents in 60 Seconds with a Single API Call

Anton Fredriksson — Tue, 21 Apr 2026 18:27:57 +0000

Your LLM agent is stuck in a token loop. It's burning $50/hour. You're asleep. What happens next?

Without a killswitch — disaster. With AgentSafety, one HTTP call stops it in under 60 seconds.

The Problem Nobody Talks About

LLM agents go off the rails. A lot.

🔄 Token loops — agent retries the same failing action 10 000 times
💸 Budget drain — $5 of API credits gone before lunch
🌙 Midnight runs — agent decides 3 AM is a great time to scrape the entire web
🤖 Infinite retries — one broken endpoint = thousands of wasted calls

Most teams discover this after the bill arrives.

What AgentSafety Does

A simple HTTP-based control plane for any AI agent — no SDK, no rewrite required.

🛑 KILLSWITCH — stop a runaway agent in under 60 seconds
😴 SLEEP SCHEDULE — define rest hours per agent (timezone-aware)
📊 STATUS CHECK — lightweight heartbeat your agent polls before each action
♻️ REVIVE — bring a stopped agent back online when you're ready

All endpoints are RFC 7807 compliant (Problem Details JSON) — clean errors, no surprises.

How It Works

Your agent calls one endpoint before each action cycle:

If status returns should_run: true → continue
If status returns should_run: false → pause until next check

That's it. Three lines of integration code. Total peace of mind.

Real Use Cases

🔧 Production agents — kill switch when something goes wrong at 2 AM
💰 Cost control — auto-pause expensive agents during off-hours
🌍 Timezone-aware ops — agent sleeps 22:00–06:00 in user's local time
🧪 Testing — pause all agents instantly during deploys
🛡️ Compliance — provable audit trail of when agents ran or stopped

Why This Matters Now

Autonomous agents are exploding in production. Frameworks like LangChain, AutoGPT, CrewAI and custom GPT runtimes all share one weakness: no remote off-switch.

AgentSafety fills that gap with a vendor-neutral, framework-agnostic API. Works with any agent that can make an HTTP call.

Pricing

Basic — $9/month, 1 000 requests, 100 agents max
Pro — $19/month, 5 000 requests, unlimited agents ⭐ recommended
Mega — $49/month, 25 000 requests, unlimited agents

Get Started

Five endpoints. RFC 7807 errors. Stop runaway agents before they stop your budget.

👉 Try AgentSafety on RapidAPI: https://rapidapi.com/fredrikssonanton01/api/agentsafety

Building autonomous agents? What's your worst runaway story? Drop a comment below 👇

Convert Markdown to PDF via API in 30 Seconds

Anton Fredriksson — Tue, 14 Apr 2026 08:18:28 +0000

Tired of writing complex HTML or wrestling with PDF libraries? MarkdownPDF turns plain Markdown into beautifully styled PDFs in a single API call.

Perfect for invoices, reports, documentation, receipts, and newsletters — no design skills required.

What MarkdownPDF Does

Send Markdown → get a professional PDF back. That's it.

✅ Zero setup — no libraries, no headless browsers
✅ 6 built-in themes — pick one and you're done
✅ Fast — PDFs generated in under 2 seconds
✅ Stateless — your content is never stored

Why Markdown Instead of HTML?

Writing HTML for PDFs is painful. CSS for print is worse. Markdown is:

Readable — your team can edit it without training
Version-control friendly — clean diffs in Git
Portable — works everywhere, breaks nowhere

Quick Example

A single POST request to https://markdownpdf.p.rapidapi.com/markdownpdf with your markdown, a theme (professional, modern, classic, minimal, elegant, or technical), and page size (A4 or Letter) returns a ready-to-download PDF.

Full code example with fetch, axios, Python and cURL is available in the Code Snippets tab on the RapidAPI page — copy-paste ready.

Real Use Cases

📄 Invoices & receipts — auto-generate from order data
📊 Reports — turn analytics into shareable PDFs
📚 Documentation — convert docs to downloadable guides
📧 Newsletters — archive emails as PDF attachments
🎓 Certificates — generate course completions on demand

6 Themes to Choose From

Professional — clean, corporate look
Modern — minimal with bold headers
Classic — timeless serif typography
Minimal — pure focus on content
Elegant — refined, premium feel
Technical — perfect for docs and code

Pricing

Basic — $5/month, 1 000 PDFs
Pro — $19/month, 10 000 PDFs

Get Started

Markdown in. PDF out. No drama.

👉 Try MarkdownPDF on RapidAPI: https://rapidapi.com/fredrikssonanton01/api/markdownpdf

Have feedback or feature requests? Drop a comment below 👇

How to Humanize AI Text with One API Call

Anton Fredriksson — Tue, 14 Apr 2026 08:12:59 +0000

AI-generated text is everywhere — but it often sounds like AI. Repetitive patterns, robotic phrasing, and that uncanny "ChatGPT voice" that readers (and AI detectors) spot instantly.

I built ChromaWrite to solve this. It's a text processing API on RapidAPI that transforms AI-generated text into natural, human-sounding writing — with a single API call.

What ChromaWrite Does

Five actions, one endpoint:

Rewrite — Improve clarity and flow
Grammar — Fix every error instantly
Tone — Shift between formal, casual, professional, friendly, or academic
Humanize — Convert AI text into natural human writing
Summarize — Condense long texts into short, medium, or long summaries

Why Not Just Prompt Engineer?

You could ask ChatGPT to "sound more human" — but:

Inconsistent results — Every prompt gives different quality
No API — You can't automate prompt engineering in a pipeline
Token waste — Burning tokens on meta-instructions instead of content
No specialization — ChromaWrite's humanize model is tuned for this task

Quick Example

const response = await fetch('https://chromawrite.p.rapidapi.com/chromawrite', {
  method: 'POST',
  headers: {
    'X-RapidAPI-Key': process.env.RAPIDAPI_KEY,
    'X-RapidAPI-Host': 'chromawrite.p.rapidapi.com',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    text: 'Your AI-generated text here',
    action: 'humanize'
  })
});

const { result } = await response.json();
console.log(result);
// "Using better methods helps you get the best results."

Real Use Cases

Content publishers — Run AI drafts through ChromaWrite before publishing
SEO teams — Bulk-process AI content without the robotic tone
Email marketing — Humanize AI-written campaigns so they feel personal
Chatbots — Post-process bot responses to sound more natural

Pricing

Basic ($9/mo) — 5,000 requests. Includes rewrite, grammar, and tone.
Pro ($19/mo) — 25,000 requests. All 5 actions including humanize and summarize.

No free tier. Professional tool, professional pricing.

Get Started

ChromaWrite on RapidAPI: https://rapidapi.com/fredrikssonanton01/api/chromawrite

Documentation & Examples: https://fyrnity.com/tools

Built by Fyrnity — developer tools that just work.