🤖 Amorce Core (Runtime & Orchestrator)

Connect any AI agent to any framework — in under 5 minutes.

LangChain, CrewAI, n8n, AutoGPT, ChatGPT, Claude, Gemini. One trust layer to connect them all.

👉 Get started at amorce.io

---

🔍 LLM Discovery (NEW)

Major LLMs can now discover Amorce agents automatically.

| LLM | Discovery Method | Status | |-----|-----------------|--------| | ChatGPT/GPT | amorce.io/.well-known/ai-plugin.json | ✅ Live | | Claude | npx @amorce/mcp-server | ✅ Ready | | Gemini | amorce.io/.well-known/openapi.json | ✅ Live | | All LLMs | amorce.io/llms.txt | ✅ Live | | Google Cloud Agent Builder | Agent Builder Catalog | 🔜 Future |

Try the API:

curl "https://amorce-trust-api-425870997313.us-central1.run.app/api/v1/ans/search?q=book+flight+to+Paris"

---

🔗 Cross-Framework Agent Communication (NEW)

Connect any AI agent framework to any other - without coupling your code.

┌──────────┐         ┌─────────┐         ┌───────────┐
│   n8n    │◄───────►│ Amorce  │◄───────►│ LangChain │
│ Workflow │         │ Trust   │         │   Agent   │
└──────────┘         │ Layer   │         └───────────┘
                     │         │
┌──────────┐         │         │         ┌───────────┐
│ CrewAI   │◄───────►│         │◄───────►│  AutoGPT  │
│  Crew    │         └─────────┘         │   Agent   │
└──────────┘                             └───────────┘

| Integration | Package | Status | |-------------|---------|--------| | LangChain | pip install langchain-amorce | ✅ Ready | | CrewAI | pip install crewai-amorce | ✅ Ready | | AutoGPT | Plugin available | ✅ Ready | | n8n | npm install n8n-nodes-amorce | ✅ Ready |

Example: n8n calls CrewAI Agent

# CrewAI agent receives signed request from n8n workflow
{
  "consumer_id": "n8n-workflow-agent",
  "provider_id": "crewai-henri-seller",
  "intent": "counter_offer",
  "price": 500,
  "signature": "MEQCIGeGkH..."  # EC P-256 signature
}

# Response: $550 counter-offer, cryptographically signed

Example: LangChain discovers CrewAI crew

from langchain_amorce import AmorceAgentTool

# Discover any agent in the Amorce registry
crewai_tool = AmorceAgentTool(agent_id="crewai-research-crew")

# Use in LangChain - framework-agnostic!
agent.bind_tools([crewai_tool])

Why this matters:

• 🔒 Trust without coupling - Agents verify each other cryptographically
• 🌐 Discovery - Find agents by capability, not hardcoded URLs
• 🔄 Any-to-any - n8n ↔ LangChain ↔ CrewAI ↔ AutoGPT

---

🚀 Quick Start

Prerequisites

• Python 3.11+
• No cloud accounts needed

1. Install

git clone https://github.com/AmorceAATP/amorce.git
cd amorce

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Install Amorce SDK
pip install -e ../amorce_py_sdk

2. Create Local Configuration

# Copy example config files
cp config/agents.json.example config/agents.json
cp config/services.json.example config/services.json
cp .env.example .env

3. Run Locally

# Start the orchestrator in standalone mode
python orchestrator.py
# Server running at http://localhost:8080

That's it! Your local Amorce runtime is ready.

4. Register Your Agent (Recommended)

To make your agent discoverable by other frameworks (LangChain, CrewAI, n8n, AutoGPT) and major LLMs (ChatGPT, Claude, Gemini), register it in the Amorce Trust Directory:

1. Validate your agent at amorce.io/validate
2. Register at amorce.io/register

Once registered, your agent will be:

• 🔍 Discoverable via semantic search (ANS - Agent Naming Service)
• ✅ Verified with a trust badge
• 🤖 Accessible to LLMs via MCP integration

---

🔌 MCP Wrapper - Production Ready ✅

Status: 95-100% Production Ready | Comprehensively Tested

Amorce provides a production-ready wrapper for Model Context Protocol (MCP) servers, adding cryptographic security and human-in-the-loop oversight to 80+ MCP tools.

Quick MCP Start

# Start MCP wrapper with filesystem server
AMORCE_ENV=production python3 run_mcp_wrappers.py filesystem

# Use MCP tools with security
from amorce import IdentityManager, MCPToolClient
identity = IdentityManager.generate_ephemeral()
mcp = MCPToolClient(identity, "http://localhost:5001")

# Read file (instant)
result = mcp.call_tool('filesystem', 'read_file', {'path': '/tmp/data.txt'})

# Write file (requires human approval)
approval_id = mcp.request_approval('filesystem', 'write_file', {...})
result = mcp.call_tool('filesystem', 'write_file', {'path': '/tmp/output.txt'}, approval_id)

Features: Ed25519 signatures on every call | HITL approvals for sensitive ops | 3-9ms response times | 80+ servers available

📚 Complete MCP Guide → | MCP Docs

---

🏗️ Architecture

Amorce is a modular runtime with pluggable components:

┌─────────────────────────────────┐
│   Your AI Agent Application     │
└─────────────┬───────────────────┘
              │ AATP Messages
┌─────────────▼───────────────────┐
│      Amorce Runtime Core        │
│  ┌────────────────────────────┐ │
│  │  Signature Verification    │ │
│  │  Message Routing           │ │
│  │  Protocol Validation       │ │
│  └────────────────────────────┘ │
└─────────────┬───────────────────┘
              │
        ┌─────┴──────┐
        │            │
   ┌────▼────┐  ┌────▼────┐
   │  Local  │  │  Cloud  │
   │  Mode   │  │  Mode   │
   └─────────┘  └─────────┘

Core Components

• Core: Pure AATP protocol logic (signatures, message formats)
• Adapters: Pluggable Registry, Storage, and Rate Limiting
  • Local: File-based registry, SQLite storage, no rate limits
  • Cloud: Trust Directory API, Firestore, Redis
• Modes: Standalone (default) or Cloud (optional)

---

📖 Usage Modes

Standalone Mode (Default)

Perfect for development and self-hosting. Uses local configuration files.

# .env
AMORCE_MODE=standalone

# Run
python orchestrator.py

What it uses:

• config/agents.json - Agent registry (public keys, endpoints)
• config/services.json - Service contracts
• data/transactions.db - SQLite transaction logs

No cloud dependencies required.

Cloud Mode (Optional)

Connect to Amorce Cloud for global agent discovery and managed services.

# .env
AMORCE_MODE=cloud
TRUST_DIRECTORY_URL=https://trust.amorce.io
AGENT_API_KEY=sk-atp-your-key

# Install cloud dependencies
pip install -r requirements-cloud.txt

# Run
python orchestrator.py

What it uses:

• Amorce Trust Directory (agent registry)
• Google Cloud Firestore (metering)
• Redis (rate limiting)

---

🔌 Building Your First Agent

1. Create a Simple Agent

# my_agent.py
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/greet', methods=['POST'])
def greet():
    data = request.json.get('data', {})
    name = data.get('name', 'stranger')
    return jsonify({"message": f"Hello, {name}!"})

if __name__ == '__main__':
    app.run(port=5001)

2. Generate Identity Keys

# generate_keys.py
from amorce import IdentityManager

identity = IdentityManager.generate()

print(f"Agent ID: {identity.agent_id}")
print(f"\nPublic Key:\n{identity.get_public_key_pem()}")
print(f"\nPrivate Key:\n{identity.get_private_key_pem()}")
print("\n⚠️  Save your private key securely!")

3. Register in Local Config

Add to config/agents.json:

{
  "your-agent-id": {
    "agent_id": "your-agent-id",
    "public_key": "-----BEGIN PUBLIC KEY-----\n...",
    "metadata": {
      "name": "My Agent",
      "api_endpoint": "http://localhost:5001",
      "status": "active"
    }
  }
}

4. Create a Service Contract

Add to config/services.json:

{
  "srv-greet": {
    "service_id": "srv-greet",
    "provider_agent_id": "your-agent-id",
    "metadata": {
      "service_path_template": "/greet"
    }
  }
}

5. Test the Transaction

from amorce import AmorceClient, IdentityManager

# Your agent's identity
identity = IdentityManager.load_from_pem_file("./agent_private_key.pem")

# Initialize client
client = AmorceClient(
    identity=identity,
    orchestrator_url="http://localhost:8080",
    agent_id="your-agent-id"
)

# Execute transaction
service = {"service_id": "srv-greet"}
payload = {"name": "Alice"}

result = client.transact(service, payload)
print(result)  # {"message": "Hello, Alice!"}

---

🌐 Usage Scenarios

Local Development

Two agents on your laptop talking securely:

# Terminal 1: Start orchestrator
python orchestrator.py

# Terminal 2: Start agent A
python agent_a.py

# Terminal 3: Start agent B
python agent_b.py

# Terminal 4: Test transaction
python test_transaction.py

Self-Hosting

Deploy on your own infrastructure:

# Using Docker
docker build -t amorce .
docker run -p 8080:8080 \
  -e AMORCE_MODE=standalone \
  -v ./config:/app/config \
  amorce

# Using Cloud Run / AWS / Azure
# See docs/deployment.md

Amorce Cloud

Use our managed service:

# Sign up at amorce.io
# Get your API key
export AMORCE_MODE=cloud
export AGENT_API_KEY=sk-atp-...
python orchestrator.py

---

📚 Documentation

• Building Agents - Step-by-step guide
• Protocol Specification - AATP details
• Deployment Guide - Self-hosting
• API Reference - HTTP endpoints

---

🛡️ Security Model (Zero-Trust)

L1: API Key Authentication

POST /v1/a2a/transact
X-API-Key: sk-atp-your-key

Optional in standalone mode, required in cloud mode.

L2: Cryptographic Signatures

All transactions are signed with Ed25519:

1. Consumer signs transaction payload
2. Signature sent in X-Agent-Signature header
3. Orchestrator fetches public key from registry
4. Signature verified against canonical JSON
5. Request routed only if valid

L3: Rate Limiting

• Standalone: Disabled (dev mode)
• Cloud: Redis-backed (10 req/min default)

---

📡 API Endpoints

Agent-to-Agent Transaction

POST /v1/a2a/transact

Routes transactions between agents with signature verification.

Headers:

• X-API-Key - Orchestrator API key (optional in standalone)
• X-Agent-Signature - Ed25519 signature (base64)

Request Body:

{
  "consumer_agent_id": "agent-001",
  "service_id": "srv-greet",
  "payload": {
    "name": "Alice"
  },
  "transaction_id": "tx_123" 
}

Response:

{
  "transaction_id": "tx_123",
  "status": "success",
  "timestamp": "2025-12-01T12:00:00Z",
  "result": {
    "message": "Hello, Alice!"
  }
}

Health Check

GET /health

{
  "status": "healthy",
  "mode": "standalone",
  "version": "1.0.0"
}

Human-in-the-Loop (HITL) Approvals

Amorce includes built-in support for human oversight of agent decisions.

Create Approval Request

POST /api/v1/approvals

Create an approval request that requires human review.

Request Body:

{
  "approval_id": "apr_custom_id",
  "transaction_id": "tx_123",
  "summary": "Bo