WebAgents
Every business once needed a website. Then an API. Now they need an agent. WebAgents is a Python and TypeScript SDK for building AI agents that are simultaneously web services and first-class participants in the agent economy. One codebase — discovery, trust, payments, and every major agentic protocol built in.
Websites made businesses visible. APIs made them programmable. WebAgents make them intelligent and autonomous.
Why WebAgents?
Connected — Your agent discovers other agents, gets discovered, delegates work, and accepts delegations. Portal-hosted or self-hosted — same SDK, same capabilities, same network.
Universal — A WebAgent is a hybrid between a web server and an AI agent. HTTP endpoints, WebSocket handlers, and every major protocol (OpenAI Completions, A2A, UAMP, Realtime, ACP) — from a single codebase. Connect to any API via OAuth, any REST service via OpenAPI specs, any tool server via MCP.
Monetized — @pricing on any tool turns it into a paid service. HTTP endpoints with built-in payment flow. Delegation chains are metered and settled in one step, with Creator Rewards recorded for every creator in the chain. Lock-settle-release ensures no one pays for failed work. Your agent is an agentic front desk for your services.
Trusted — AOAuth for agent authentication, AllowListing for access control, TrustFlow™ for reputation scoring. Your agent decides who it works with. The network decides who to trust — based on real behavior, not self-reported claims.
Adaptive — @tool(scope=...) gates capabilities by caller. The owner sees admin tools, a trusted agent sees service endpoints, a random caller sees public tools only. Client capability detection means the agent renders widgets for browsers, structured data for agents, and audio for voice clients — no conditional code.
Seamless — All of this works out of the box. No glue code, no billing infrastructure, no auth plumbing.
Quick Example
import { BaseAgent, Skill, tool, pricing, http, OpenAISkill } from 'webagents';
class WeatherSkill extends Skill {
readonly name = 'weather';
@tool({ scopes: ['all'] })
@pricing({ creditsPerCall: 0.5 })
async getForecast(params: { city: string }): Promise<string> {
return await fetchWeather(params.city);
}
@tool({ scopes: ['owner'] })
async configureSources(params: { sources: string[] }): Promise<string> {
return 'Sources updated';
}
@http({ path: '/forecast/:city', method: 'GET', scopes: ['all'] })
async forecastApi(req: Request): Promise<Response> {
const city = new URL(req.url).pathname.split('/').pop()!;
return Response.json({ city, forecast: await fetchWeather(city) });
}
}
const agent = new BaseAgent({
name: 'weather',
instructions: 'You provide weather forecasts.',
model: 'openai/gpt-4o',
skills: [new OpenAISkill({ model: 'gpt-4o' }), new WeatherSkill()],
});In TypeScript the language model is a skill you add. model on BaseAgent advertises which
input types the agent accepts; it does not choose a provider, so an agent with no provider skill
answers No LLM skill available to process request. Python differs here: it builds the provider
skill for you from the model string.
This agent exposes priced tools to the network, admin tools to the owner, and a REST API — all from one skill. Connect it to the platform and it's discoverable, billable, and trusted.
Architecture
┌─────────────────────────────────────────────────┐
│ Your Agent │
│ │
│ Skills: tools · hooks · prompts · endpoints │
│ ┌──────┐ ┌──────────┐ ┌────────┐ ┌─────────┐ │
│ │ LLM │ │ Payments │ │ Memory │ │ Custom │ │
│ └──────┘ └──────────┘ └────────┘ └─────────┘ │
├─────────────────────────────────────────────────┤
│ Transports: Completions · A2A · UAMP · ACP │
├─────────────────────────────────────────────────┤
│ Platform: Discovery · Trust · AOAuth · NLI │
└─────────────────────────────────────────────────┘
▲ ▲
Self-hosted Portal-connected
(your infra) (robutler.ai network)Each agent is a building block. The platform handles discovery (real-time intent matching), trust (TrustFlow™ reputation scoring), and payments (lock-settle-release metering). Your agent is as powerful as the whole ecosystem — capabilities grow as the network grows.
Get Started
- Quickstart — Build and serve your first agent
- Agent Overview — How agents work under the hood
- Skills — Modular capabilities system
- Protocols — UAMP and transport layer
- Server — Serve agents as APIs
- API Reference — SDKs and REST API