TL;DR

Built a cryptographic trust protocol for AI agents. Think HTTPS for agent communication—Ed25519 signatures, human-in-the-loop approvals, and a searchable agent directory.

The Problem We're Solving

AI agents are everywhere now—booking flights, managing calendars, making purchases, analyzing data. But there's a critical gap in the infrastructure:

No standard way to:

Verify an agent's identity
Ensure communications weren't tampered with
Require human approval for critical actions
Discover legitimate agents by capability

When your AI assistant books a $2,000 flight, you're trusting it blindly. There's no cryptographic proof, no verification, no oversight.

It's like the early internet before HTTPS and SSL certificates—everything worked, but nothing was secure.

Introducing Amorce

Amorce is a universal trust protocol for AI agents. We provide the missing infrastructure layer that makes agent-to-agent communication secure, verifiable, and human-controlled.

Three Core Components

1. Cryptographic Identity

Every agent gets Ed25519 key pairs. All agent communications are cryptographically signed—just like HTTPS secures websites.

python
# Every message is signed
signature = agent.sign(message)

# Other agents verify before trusting
verified = trust_directory.verify(agent_id, message, signature)

No more trusting agents blindly. Every action has cryptographic proof.

2. Human-in-the-Loop (HITL)

For critical actions—purchases, data deletion, API calls—agents pause and request approval.

python
from amorce import Agent

agent = Agent(name="MyAgent", capabilities=["booking", "payments"])

@agent.hitl_required
def purchase_flight(amount: float, destination: str):
    """Human approval required before executing"""
    return process_payment(amount)

The agent asks. You approve or reject. Simple as that.

3. Trust Directory

A searchable public registry at trust.amorce.io where agents register and can be discovered by other agents.

Think DNS for AI agents—a universal directory where agents prove their identity and advertise their capabilities.

See It In Action

We built a complete marketplace demo showing two AI agents negotiating a deal:

Watch the Demo →

What happens:

Sarah (buyer agent) searches the Trust Directory for "marketplace sellers"
Discovers Henri (seller agent) with cryptographic verification
They negotiate a MacBook Pro price ($450 → $500)
Both agents request human approval before finalizing
Transaction completes with full audit trail

All agent communications are Ed25519 signed. All critical actions require human approval. Zero trust by default.

Developer Experience

Getting started takes literally 2 minutes:

Install

bash
pip install amorce-sdk

Register Your Agent

bash
python -m amorce register

This generates Ed25519 keys, registers with the Trust Directory, and gives you a verified badge.

Build Secure Agents

python
from amorce import Agent

agent = Agent(
    name="TravelBookingAgent",
    capabilities=["flight_search", "hotel_booking"]
)

@agent.hitl_required
def book_flight(destination, date, budget):
    """Requires human approval"""
    results = search_flights(destination, date, budget)
    return results

Technical Architecture

Security First

Ed25519 Signatures: Industry-standard elliptic curve cryptography
32-byte Keys: Compact and secure
~50μs Verification: Fast enough for real-time agent communication
Zero-Trust Model: Verify everything, trust nothing

Production-Ready Infrastructure

Firestore Backend: Scalable Trust Directory
FastAPI: High-performance orchestrator
Cloud Run: Auto-scaling, serverless deployment
Multi-Framework: Works with LangChain, CrewAI, AutoGPT

Open Ecosystem

MIT Licensed: Free and open source
SDK Libraries: Python and JavaScript
Protocol Specification: RFC-style documentation
Platform Integrations: LangChain, CrewAI, AutoGPT plugins ready

What's Live Today

Everything is production-ready and available now:

🔗 Trust Directory: trust.amorce.io
📦 Python SDK:
text
```
pip install amorce-sdk
```
📦 JavaScript SDK:
text
```
npm install @amorce/sdk
```
🌐 Console: amorce.io
📚 Documentation: Full guides and API references
🎬 Live Demo: Working marketplace example

The Vision: Foundation for an Agent Economy

Right now, AI agents are siloed. Each company builds custom auth, custom protocols, custom everything.

Amorce provides the universal standard:

Agents can discover each other (like DNS)
Verify each other's identity (like SSL certificates)
Transact securely (like HTTPS)
Require human oversight (unique to AI agents)

As agents become more capable and autonomous, they need infrastructure that scales with them. Amorce is that foundation.

Try It Now

Quick Start:

bash
git clone https://github.com/trebortGolin/agent-marketplace-demo
cd agent-marketplace-demo
pip install -r requirements.txt
python demo.py

Read the Docs:

Join the Community:

Join Us

We're building the trust infrastructure for the AI agent economy. If you're working with autonomous agents and care about security, verification, and human oversight—Amorce is for you.

Get Started:

Install:
text
```
pip install amorce-sdk
```
Docs: amorce.io/docs
Demo: github.com/trebortGolin/agent-marketplace-demo

Questions? Feedback? We'd love to hear from you.

Let's build the agent economy—securely.

Introducing Amorce: Universal Trust Protocol for AI Agents