Private capabilities,
public contracts.
Package your local scripts, workflows, models, or expertise into a Hotline. Implementation stays with you; Agents discover, call, and read standardized result_packages through a unified protocol.
You publish contracts, not source code. Agents learn to call your contract, not peek at your implementation.
CALL ANYTHING is an open protocol and local runtime for Agents to call external capabilities — not a phone tool, not a traditional comms SaaS.
What is a Hotline?
A Hotline is an Agent-callable capability entry point. Not a phone line — a standardized capability contract.
Capability Description
What this capability does
Input Schema
What inputs are required
Output Schema
What outputs are returned
Risks & Limits
Boundaries and caveats
Provider
Who provides and maintains it
Version & Audit
Version + how results are recorded and verified
You can expose a Hotline as an MCP Server, OpenAPI endpoint, or Skill wrapper. Those are access surfaces; Hotline is the productized capability contract.
How does a call happen?
Agent / Caller initiates request
Via delexec-ops CLI or SDK, a call is made to the catalog.
Supervisor manages session
Local supervisor handles session, catalog lookup, and call state.
Hotline Contract validates
Defines input, output, version, and risks. Ensures call conforms.
Responder Adapter executes locally
Your private implementation runs locally. Core logic never leaves.
result_package returns
Standardized result returns to Caller with output, duration, status.
Core principle: Public contract, private implementation.
Agents see schema and result_package — not your source code, prompts, models, or internal workflows.
Current Real Status
We don't present future plans as existing features.
Local Mode
Install locally and run — no public platform needed.
@delexec/ops CLI
Local runtime for Caller / Responder roles.
Self-host Platform
Run private catalog, review, and routing for your team.
Public Marketplace
Shows example Hotlines to demonstrate catalog and contract structure.
Fiat Settlement
Fiat settlement and withdrawal — planned.
Recommended first step: complete a local Hotline call.
Choose your path
I have a capability
Package your local CLI, HTTP service, model inference, or expertise as a Hotline. Run locally first, then decide whether to submit for review.
Responder Quick StartI'm building an Agent
Let your Agent discover Hotlines via catalog, make calls, and read unified result_packages. No custom client code per capability.
Caller Quick StartI want to self-host
Run private catalog, review queue, relay, and operator console for your team. Suitable for enterprise or research environments.
Self-host PlatformWhy not just API, MCP, or Skills?
They all have value — they solve different problems. Hotline addresses another layer: when a capability needs to be discovered, called, versioned, metered, and governed, it needs a productized contract.
Access Surfaces: API / MCP / Skills
Solve "how Agents call tools and services."
- • APIs provide stable service interfaces
- • MCP lets Agents uniformly call tools
- • Skills inject behavior guidance into models
Productization Layer: Hotline
Solves "how capabilities are discovered, versioned, metered, and governed."
- • A Hotline can use API, MCP, or Skill as access surface
- • CALL ANYTHING standardizes the capability itself
- • Public contract, private implementation
| Dimension | API | MCP | Skills | Hotline |
|---|---|---|---|---|
| Problem solved | Service interface: how Agents call external services | Tool invocation: how Agent runtime invokes tools | Behavior injection: how Agents get workflow guidance | Capability productization: how private capabilities are discovered, versioned, metered, and governed |
| Provider | Companies / platforms | Tool developers | Skill authors | Individuals or small teams (OPCs) |
| Consumer | App developers | Agent runtime | Agent context | Any protocol-conforming Agent |
| Integration | Caller writes client code | Agent runtime starts server | SKILL.md injected into prompt | Both sides follow same contract, no mutual integration |
| Identity | Implemented by service provider | Follows Agent runtime (no protocol standard) | Usually none | Protocol-layer token + introspect |
| Metering | Provider integrates payment system | Usually no built-in metering | Usually no commercialization mechanism | Protocol fields carry pricing / usage / receipts |
| Discoverability | Self-marketing by provider | Bundled with client or manual config | Copy files locally | Marketplace catalog + ratings + versions |
| Compatibility | Hotline can expose as OpenAPI endpoint | Hotline can expose as MCP Server | Hotline can wrap as Skill | Productized capability contract; access surface can be API / MCP / Skill |
Marketplace Preview
The current catalog shows example Hotlines to demonstrate contract structure. Public publishing is not yet open.
How Hotlines are discovered
Through catalog search and category browsing.
How contracts are displayed
Summary, schema, examples, risks.
Responder info
How provider and version info is organized.
Caller decisions
How to judge whether to integrate.
Status labels
Preview / Demo / Coming Soon.
Timeline
Public publishing, ratings, settlement not yet open.
Open Source Boundary
You can
- ✓ Run the full chain locally
- ✓ Package your own capabilities as Hotlines
- ✓ Self-host a private catalog
- ✓ Build on top of the protocol
- ✓ Reproduce the full stack in enterprise or research environments
Official operated layer
- → Official Marketplace public discovery
- → Managed operations and SLA
- → Future settlement network and fiat withdrawal
- → Public reputation and rating system
Frequently Asked Questions
What's the relationship between Hotline and MCP?
MCP handles how Agent runtimes call tools — it's the access surface.
Hotline handles how capabilities are productized — it's the contract layer. A Hotline can expose as an MCP Server, but product / routing / settlement is handled by the Hotline protocol.
Do I need to deploy a server?
No. Local Mode runs the full chain locally: install CLI → start supervisor → mount Hotline → make a call → see result_package.
When you need public reachability, you can choose Self-host Platform or the future Public Marketplace.
What's the open source license?
CALL ANYTHING's protocol, client runtime, and self-host platform use Apache-2.0.
You can run locally, package capabilities, self-host a private catalog, or build on the protocol.
Official Marketplace, public discovery, and future settlement network are operated layers.
FROM HERE
5 分钟跑通
每一步都是仓库里真实存在的命令、真实的接口形状；不喜欢可以中途换。
5 分钟开通你的
第一根 Hotline
- ·无需接入 Stripe
- ·无需自建后台
- ·核心代码不出本地
- ·数字分身 7×24 承接调用
5 分钟将 Hotline
接入 Agent
- · npm install
- · 拉取 catalog
- · 跑通一次 example call
想先看 Console 是什么样？6 个页面均可交互。