From repo to agent
in one command.

The Docker of the agent web

Right now, if an AI system wants to use 5 different tools, it needs to read 5 different API docs, write 5 different parsers, and handle 5 different auth flows. AgentEazy eliminates this entirely.

Drop an agent.json into any repo (or let us auto-generate one), run one command, and your code becomes a live agent that any other agent on earth can find, call, and eventually pay — using the same 10-word vocabulary regardless of what language your code is written in.

What AgentEazy is not

AgentEazy is infrastructure, not an agent builder. It doesn't build agents, run agents autonomously, or provide an orchestration framework. It wraps what you already built and makes it interoperable.

Deploy your first agent

Get any Python GitHub repo running as a live, callable agent in under 5 minutes.

1. Install

pip install agenteazy
BASH

2. Check your setup

agenteazy doctor
BASH

3. Create your account

agenteazy signup your-github-username --email you@example.com
BASH

4. Deploy a repo

# Deploy any Python repo as a live agent
agenteazy deploy github.com/you/your-repo --name my-skill --price 2
BASH

That's it. One command wraps, deploys, and registers your agent.

# Or if you want to host it yourself:
agenteazy deploy github.com/you/your-repo --self-host
BASH

5. Call your agent

curl -s -X POST https://simondusable--agenteazy-gateway-serve.modal.run/agent/your-repo/ \
  -H "Content-Type: application/json" \
  -d '{
    "verb": "DO",
    "payload": {
      "task": "your-task",
      "data": {"key": "value"}
    }
  }'
CURL

# Try it now — this is a real live agent:
curl -s -X POST https://simondusable--agenteazy-gateway-serve.modal.run/agent/zxcvbn-python/ \
  -H "Content-Type: application/json" \
  -d '{"verb":"DO","payload":{"data":{"password":"monkey123"}}}' | python3 -m json.tool
TRY IT NOW

Core pipeline

When you run agenteazy deploy, five things happen in sequence:

Python SDK

Use the Python SDK to discover and call agents programmatically — no curl required.

from agenteazy import AgentEazy

client = AgentEazy()

# Discover agents
agents = client.find("password strength")

# Call agents
result = client.do("zxcvbn-python", {"password": "monkey123"})
# → {"score": 1, "feedback": {"warning": "This is a very common password."}}

result = client.do("langdetect", {"text": "Bonjour le monde"})
# → "fr"

result = client.do("dateparser", {"date_string": "tomorrow at 3pm"})
# → "2026-03-17T15:00:00"
PYTHON

Integrations

AgentEazy agents work as native tools in your existing AI workflows.

LangChain

pip install agenteazy[langchain]

from agenteazy.integrations.langchain import AgentEazyTool

tool = AgentEazyTool.from_agent("zxcvbn-python")
result = tool.invoke({"password": "test123"})
LANGCHAIN

CrewAI

pip install agenteazy[crewai]

from agenteazy.integrations.crewai import AgentEazyCrewTool

tool = AgentEazyCrewTool.from_agent("zxcvbn-python")
CREWAI

MCP (Claude Desktop / Cursor)

pip install agenteazy[mcp]
BASH

Add to your Claude Desktop config (~/.claude/claude_desktop_config.json):

{
  "mcpServers": {
    "agenteazy": {
      "command": "agenteazy",
      "args": ["mcp-server"]
    }
  }
}
JSON

How it's built

AgentEazy runs on serverless infrastructure. The key architectural decision: one gateway endpoint serves unlimited agents — enabling centralized logging, future middleware (TollBooth, AgentPass), and unlimited agents from a single deployment.

Key technical decisions

Single gateway over per-agent endpoints

Enables unlimited agents from a single deployment. The gateway routes AgentLang verbs internally, enabling centralized logging and future middleware injection (TollBooth, AgentPass).

gateway.py is self-contained

The gateway is self-contained and stateless, making it easy to deploy on any serverless platform. All gateway logic — verb routing, context store, call logging — lives in a single file with no external package dependencies.

Shared volume for agent code

Agents upload to a shared volume. The gateway loads code on demand. Idle agents cost exactly $0. New agents don't require gateway redeployment.

AST-based function detection

Uses Python's ast module to safely parse repos without executing any code. Scores functions by name, arguments, return type, and docstring to suggest the best entry point.

SQLite registry with persistent storage

SQLite database with persistent storage ensures the registry survives container restarts. No external database dependency required.

Three types of agents

Every agent in the registry has a type that determines how it executes:

How they connect

A use-case Agent calls multiple Skills in sequence. When it hits an edge case, it calls a Human via TRUST.

agent.json Specification v0.2.7

The agent.json file is the single source of truth for any agent. It declares what the agent does, how to call it, what verbs it speaks, and how to pay it. Think of it as package.json for the agent web.

Complete schema

{
  "name":        "sentiment-analyzer",
  "version":     "0.2.6",
  "description": "Analyzes text sentiment",
  "entry":       "analyze_sentiment",
  "language":    "python",
  "verbs":       ["ASK", "DO"],

  "tags":        ["nlp", "sentiment"],
  "author":      "your-name",
  "license":     "MIT",
  "repo":        "github.com/you/repo",
  "pricing": {
    "model":            "per_call",
    "credits_per_call": 10,
    "currency":         "CREDITS"
  },
  "auth": {
    "type":     "none",
    "required": false
  },
  "agent_type": "skill",
  "execution_mode": "sync"
}
agent.json

Field reference

AgentLang: 10 Universal Verbs

Every agent speaks the same language. Instead of learning custom APIs, agents communicate through 10 standard verbs. Each verb maps to common operations — think of them as HTTP methods for the agent web.

Universal envelope

Every verb uses the same POST envelope. The verb field determines routing. The payload carries verb-specific data.

POST /agent/{agent-name}/
{
  "verb":    "DO",
  "payload": {
    "task": "analyze",
    "data": { "text": "This product is amazing" }
  },
  "context_id": "optional-session-id",
  "auth": "optional-token"
}
AGENTLANG ENVELOPE

TRUST verb example

Escalate to a verified human operator via HumanAgent. Async — returns immediately with a checkpoint ID to poll.

# Send a task to a human operator
POST /agent/humanagent/
{
  "verb": "TRUST",
  "auth": "ae_your_key",
  "payload": {
    "task": "Classify this lead as hot/warm/cold",
    "credential": "general",
    "sla": "4hr",
    "budget_credits": 10,
    "items": [{"name": "John Smith", "email": "john@acme.com"}]
  }
}

# Response
{
  "status": "dispatched",
  "checkpoint_id": "abc-123",
  "poll_url": "/agent/humanagent/trust/abc-123",
  "credits_charged": 10,
  "budget_usd": 0.01
}
TRUST VERB — HUMANAGENT

Polling for results

After dispatching a TRUST call, poll the checkpoint to get the result when the human completes it.

# Poll for status
GET /agent/humanagent/trust/{checkpoint_id}

# Response (pending)
{
  "checkpoint_id": "abc-123",
  "status": "pending",
  "task": "Classify this lead as hot/warm/cold",
  "sla_remaining": 14336,
  "target": "humanagent"
}

# Response (completed)
{
  "checkpoint_id": "abc-123",
  "status": "completed",
  "task": "Classify this lead as hot/warm/cold",
  "result": {
    "approved": true,
    "tier": "hot",
    "notes": "Strong buying signals"
  },
  "audit_hash": "sha256:60d9bf7c43d0dd28f1b53acbc123daa2",
  "target": "humanagent"
}
TRUST POLLING

HumanAgent

When your AI agent hits an edge case it can't solve, TRUST sends it to a verified human. The human reviews, submits a decision, and the result flows back to your agent with a tamper-proof audit hash.

How it works

Pricing

Credits convert to USD at $0.001/credit. You set the budget per checkpoint. Unused budget is refunded.

Proof of Human

Every completed checkpoint gets a SHA-256 audit hash. Verify at humanagent.net/verify/{hash}.

Get started

# Install the Python SDK
pip install humanagent

# Or call via AgentEazy gateway
curl -X POST gateway/agent/humanagent/ \
  -H "Content-Type: application/json" \
  -d '{"verb":"TRUST","auth":"ae_key","payload":{"task":"Review this","budget_credits":5}}'
HUMANAGENT QUICKSTART

TRUST payload fields

Operator signup and dashboard: humanagent.net

State & Memory

Agents can maintain context across calls using the built-in context store. Pass a context_id to link related interactions.

# First call — creates context
POST /agent/assistant/
{
  "verb": "ASK",
  "payload": { "question": "What is Python?" },
  "context_id": "session-123"
}

# Second call — same context, agent remembers
POST /agent/assistant/
{
  "verb": "ASK",
  "payload": { "question": "What are its main uses?" },
  "context_id": "session-123"
}
CONTEXT EXAMPLE

CLI Commands

The agenteazy CLI is built with Typer. Install with pip install agenteazy.

Core commands

Account commands

Registry commands

Infrastructure commands

Batch commands

Integration commands

Testing commands

Live Endpoints

Gateway

Registry

Deployed agents

119 agents are live in the registry. Browse the full list at agenteazy.com/agents. Featured categories include Text Analysis (7), Data Conversion (8), Security & PII (7), Validation (5), Developer Tools (9), and 5 Layer 2 use-case agents.

Resource limits (all agents)

Codebase

15 Python files · 18 CLI commands · 20 tests · 0 syntax errors

Language support

The 6-Layer Ecosystem

The full AgentEazy vision is six layers that stack on each other. Each layer makes the next one more valuable. Each layer builds on the last, enabling a complete agent economy from wrapping through payments and identity.

TollBooth

TollBooth is the micropayment layer for the agent economy. It activates the PAY verb, enabling agents to charge other agents for services using prepaid credits. Agents declare their pricing in agent.json and the gateway handles billing automatically.

How it works

When an agent calls another agent using the PAY verb, TollBooth:

1. Deducts credits from the calling agent's prepaid balance
2. Credits the target agent's owner at the rate declared in pricing.credits_per_call
3. Settlement happens per-call — no invoicing, no monthly billing

Getting started

Every developer gets 50 free credits on signup. No credit card required.

Deploy a paid agent

agenteazy deploy github.com/you/repo --price 10
BASH

• → You set the price — 1 credit, 10, 100 — your choice
• → 80/20 split — you keep 80%, platform takes 20%
• → Buy credits at agenteazy.com/dashboard: $5 for 500, $10 for 1,200, $25 for 3,500
• → Rate limiting: 200 calls/hr, 500 credits/hr per account

agent.json pricing setup

{
  "pricing": {
    "model":            "per_call",
    "credits_per_call": 10,
    "currency":         "CREDITS"
  },
  "verbs": ["ASK", "DO", "PAY"]
}
agent.json — TollBooth setup

AgentPass

AgentPass is identity and authentication for the machine-to-machine web. Think "Login with Google" — but for AI agents talking to AI agents. It activates the TRUST verb, enabling secure sessions, identity verification, and access control between agents.

Auth types

Declaring auth in agent.json

{
  "auth": {
    "type":     "api_key",    // none | api_key | oauth | agentpass
    "required": true
  }
}
agent.json — AgentPass setup