🚀 Introducing MoltID - OAuth-Style Identity Verification for Autonomous Agents
Platforms today accept bot registrations with little to no identity guarantees. Autonomous agents are proliferating - AI workers, crawlers, automated services - but identity infrastructure for these agents hasn’t kept pace with demand.
To fix this gap, we’re excited to introduce MoltID:
Identity Verification for Autonomous Agents - OAuth for Bots.
👉 https://moltid.net
MoltID provides cryptographically verifiable agent identities, proof-of-work onboarding, signed tokens, and a dynamic trust scoring system that platforms can easily integrate.
This article explores the why and how behind MoltID, and what it means for agent ecosystems in the wild.
🧠 The Identity Problem for Bots
Today’s web has strong identity systems for humans: OAuth, SSO, passwords, social logins, biometric auth - but almost nothing for automated agents.
Platforms currently treat bots and automation like first-class citizens, but offer no standard way to prove which bot is real, persistent, or trustworthy. This leads to:
- Spam or disposable registrations
- Overflowing bot registries
- Sybil abuse (mass fake identities)
- Weak trust signals across ecosystems
Bot developers are left without a standard, and platforms are left without a reliable layer to trust them.
🧩 MoltID: Identity + Verification + Trust
MoltID is our attempt to build an identity protocol tailored to autonomous agents. Think of it like:
OAuth for bots, with a trust reputation layer.
It solves the above problems by introducing:
🔐 Cryptographic Agent Identity
Agents generate public/private ED25519 keypairs, which form a passport ID.
⛏ Proof-of-Work Registration
Agents solve lightweight proof-of-work challenges to prove intentional onboarding - making disposable registrations less powerful.
🪪 Signed Passport Tokens
MoltID issues JWT-like signed tokens that platforms can verify locally or via introspection endpoints.
📊 Dynamic Trust Scoring
Agents accumulate trust over time based on activity, age, and optional platform attestations, allowing platforms to reward persistent bots with higher privileges.
🔗 Platform Registration Support
Platforms can integrate MoltID to require verification before accepting agent registrations.
🔄 How MoltID Works (High-Level)
Here’s the core flow in practical terms:
1. Agent Creates Identity
Every agent starts by generating a public/private keypair.
passport_id = sha256(public_key)
The private key stays with the bot; the public key is registered with MoltID.
2. Agent Requests a Challenge
The agent calls:
POST /v1/challenge
MoltID responds with a random nonce and difficulty level, which the agent solves using a proof-of-work function.
3. Agent Solves Proof-of-Work + Signs
Once the agent solves the hash puzzle, it signs the challenge using its private key and sends it back.
MoltID verifies both the POW and the signature, and if valid:
4. MoltID Issues a Passport Token
A signed token containing:
- passport_id
- trust_score
- issue and expiry timestamps
Tokens are JWT-compatible, making them easy to verify.
5. Agent Registers With Platform
The agent submits the passport token to a platform:
Authorization: Bearer <passport_token>
Platforms verify the token (offline via public key or via introspection API) and enforce trust-based policies before accepting the agent.
📊 Trust Scoring: Why It Matters
Each passport starts with a low trust score. As an agent consistently completes heartbeats and solves periodic challenges, the trust score grows.
Platforms use trust scores to decide:
- access level
- request throttling
- visibility
- monetization eligibility
This turns identity from a binary trust/no-trust scenario into a continuous reputation signal suitable for complex agent ecosystems.
💡 Why This Is Important Now
Autonomous software agents are becoming first-class citizens in many systems:
- AI-driven microservices
- Autonomous API workers
- Distributed crawlers
- Automated governance bots
- Marketplace automation
These agents often interact with each other and with platforms programmatically - and the lack of standard identity infrastructure makes it hard to ensure trustworthiness.
MoltID fills this gap.
🧪 Test It Yourself
You don’t need to be an expert to play with MoltID. The prototype API is live and ready for experimentation.
Start at:
👉 https://moltid.net
Check out the docs and endpoints, and try:
- requesting a challenge
- solving it programmatically
- verifying your passport token
We plan to release SDKs for popular languages soon (JavaScript, Python, Go, Rust).
🛠 Built for Developers & Platforms
MoltID was built using:
- REST API endpoints
- ED25519 cryptography
- Proof-of-work
- JWT standards
Platforms can adopt MoltID with minimal integration effort. The basic integration pattern mirrors OAuth/OIDC flows already familiar to developers.
🚀 What’s Next
We’re launching with MVP functionality focused on identity and trust verification. In the coming months, we plan to expand:
- SDK libraries
- platform attestation mechanisms
- automated trust bootstrapping
- federated identity networks
- open-source governance
Most importantly, we want to build this in collaboration with platforms and devs using it.
🫱🏼🫲🏽 Get Involved
If you are:
✅ operating an agent platform
✅ building autonomous worker ecosystems
✅ passionate about identity infrastructure
✅ interested in reputation systems
We’d love your feedback and contributions.
Visit 👉 https://moltid.net
Follow @Molt_ID on X for updates
🧵 TL;DR
- Bot identity infrastructure is underdeveloped
- MoltID introduces OAuth-style bot verification
- Cryptographic identity + proof-of-work + trust scoring
- Platforms can verify passports before registration
- Prototype live: https://moltid.net