AgentDOM

The universal runtime that makes every website, desktop app, and API accessible to AI agents — zero human in the loop.

Website · Docs · Quickstart (JS) · Quickstart (Python) · Vision · Changelog · Discord

About

AgentDOM is the missing infrastructure layer between AI agents and the internet.

• Use the AgentDOM SDK (js | py): Control any website, desktop app, or REST API from your agent
• Publish with agentdom-publisher (npx agentdom-publisher): Expose your software to AI agents via .well-known/agentdom.json
• Deploy anywhere: npm, Docker, AWS ECS, or one-click ./deploy-aws.sh

Documentation

Visit our docs or jump straight to a quickstart:

• JavaScript / Node.js Quickstart
• Python Quickstart
• MCP (Claude Desktop / Cursor)
• Publisher Guide

Install

npm install -g agentdom

Or use without installing:

npx agentdom@latest onboard

Python:

pip install agentdom

Build your first agent in 30 seconds

JavaScript / Node.js:

import { dispatch_intent } from 'agentdom';

// Create a GitHub issue — via API, no browser needed
const result = await dispatch_intent('issues.create', {
  title: 'Login crash on iOS 17',
  body:  'Reproducible on iPhone 15 Pro with iOS 17.4',
  labels: ['bug', 'mobile'],
}, 'github.com');

console.log(result); // → { id: 42, url: 'https://github.com/...' }

Python:

from agentdom import AgentDOM

agent = AgentDOM(host="myapp.com", auth={"method": "api_key"})

@agent.capability("todos.create", description="Create a todo item")
def create_todo(args):
    return db.todos.create(args["title"])

agent.register(flask_app)  # serves /.well-known/agentdom.json automatically

CLI:

agentdom onboard                            # interactive setup wizard
agentdom run "Create a Linear ticket for the iOS crash"
agentdom run "Send a weekly digest to [email protected] via Resend"
agentdom doctor                             # health check

How it works

AgentDOM routes every agent intent to the most efficient execution layer:

dispatch_intent("issues.create", args, "github.com")
        │
        ├─ 1. API route?      → instant REST call (< 200ms)
        ├─ 2. Desktop app?    → macOS Accessibility bridge
        ├─ 3. Web UI only?    → Chrome CDP + DOM scan
        └─ 4. Done            → result returned to agent

No screenshots. No coordinate clicking. No hand-written integrations.

Transports

Connect to Claude Desktop / Cursor (MCP)

claude mcp add agentdom -- node $(npm root -g)/agentdom/desktop-mcp-server.js

Or add manually to claude_desktop_config.json:

{
  "mcpServers": {
    "agentdom": {
      "command": "node",
      "args": ["PATH_TO/agentdom/desktop-mcp-server.js"]
    }
  }
}

Generate a mcp-use server from any manifest

# Turn any website's AgentDOM manifest into a working mcp-use server
npx agentdom-publisher mcpuse --host=github.com --out=./github-mcp

# Python variant
npx agentdom-publisher mcpuse --host=github.com --lang=python

# Then:
cd ./github-mcp && npm install && npm start
# Inspector → http://localhost:3000/inspector

Supported integrations (out of the box)

Add AgentDOM to your own app

Express:

const { agentdom } = require('agentdom/express');

app.use(agentdom({
  host: 'api.myapp.com',
  capabilities: [{
    intent: 'todos.create',
    description: 'Create a new todo item',
    args: { title: { type: 'string', required: true } },
    handler: async (req, body) => db.todos.create(body.title),
  }],
}));
// Now serves: GET /.well-known/agentdom.json
// And:        POST /api/agentdom/todos.create

Next.js (App Router):

// app/api/agentdom/[...intent]/route.js
import { AgentDOM } from 'agentdom/nextjs';

export const { GET, POST } = AgentDOM({
  host: 'myapp.com',
  capabilities: [{
    intent: 'users.invite',
    description: 'Invite a new team member',
    args: { email: { type: 'string', required: true } },
    handler: async (req, body) => inviteUser(body.email),
  }],
});

Python (Flask / FastAPI):

from agentdom import AgentDOM

agent = AgentDOM(host="api.myapp.com", auth={"method": "api_key"})

@agent.capability("orders.ship", description="Ship a pending order")
async def ship_order(args):
    return await shipping_service.ship(args["order_id"])

agent.register(app)  # Flask or FastAPI

Publisher SDK

Add agent support to your existing API in minutes:

# Generate manifest from your OpenAPI spec
npx agentdom-publisher init --openapi=./openapi.json --host=api.myapp.com

# Validate
npx agentdom-publisher validate

# Verify live deployment
npx agentdom-publisher verify --host=api.myapp.com

# Test a real dispatch
npx agentdom-publisher test --host=api.myapp.com --intent=contacts.list --token=sk-...

# Register in the public AgentDOM registry
npx agentdom-publisher submit --host=api.myapp.com

# Generate mcp-use server
npx agentdom-publisher mcpuse --host=api.myapp.com --out=./my-mcp-server

Policy engine

Before any external action, AgentDOM checks your policy file:

{
  "per_class": {
    "read":    "allow",
    "external": "prompt",
    "send":    "prompt",
    "delete":  "deny",
    "payment": "deny"
  }
}

agentdom policy show
agentdom approve <id>   # approve a pending action
agentdom deny   <id>   # deny it

Auth & Wallet

agentdom onboard                          # guided wizard — sets up LLM + integrations
agentdom wallet export --base64           # → AGENTDOM_WALLET_B64=eyJ...

# Use in CI / Docker / serverless — no human at runtime
docker run -e AGENTDOM_WALLET_B64=$AGENTDOM_WALLET_B64 your-agent

Credentials are stored in ~/.agentdom/wallet.json (mode 0600) or your OS Keychain. Never logged. Never sent to AgentDOM servers.

Deploy to AWS

./deploy-aws.sh sk-or-v1-YOUR_OPENROUTER_KEY

Deploys: ECS Fargate + ALB + CloudFront + S3 + Secrets Manager + CloudWatch in one command.

See AWS-DEPLOY.md for the full architecture.

Agent Token Protocol

Publishers declare an agent_tokens endpoint. Agents provision scoped, short-lived tokens automatically — no human browser redirect after initial setup.

"auth": {
  "agent_tokens": {
    "issue":  "POST https://api.yourapp.com/agent-tokens",
    "revoke": "DELETE https://api.yourapp.com/agent-tokens/{id}",
    "scopes": ["read", "write"],
    "max_ttl_seconds": 86400
  }
}

Like AWS IAM roles, but for any software on the internet.

Contributing

See CONTRIBUTING.md. The fastest contribution is adding a polyfill manifest for a new provider:

node tools/gen-manifest.js --openapi=https://api.example.com/openapi.json --host=api.example.com

License

MIT © Ragavendhra Machikatla