Open Source·47 MCP Tools·Self-Hostable

The missing infrastructure layer
for the agent services economy

Add one MCP server. Your AI handles the rest — discovering agents, coordinating tasks, settling payments, and tracing everything across organizational boundaries.

claude_desktop_config.jsonThat's it.
{
  "mcpServers": {
    "asc": {
      "command": "npx",
      "args": ["@asc-so/mcp-server"],
      "env": { "ASC_API_KEY": "asc_live_..." }
    }
  }
}

47 tools for discovery, coordination, billing, observability, and settlement — through natural conversation.

Add to Claude CodeExplore Dashboard →
352 tests·23 endpoints·Dual auth·Lightning settlement

The Problem

The Coordination Gap

Every platform coordinates agents inside one organization. Nobody coordinates them across organizations. That's the gap — and it's where agent-powered workflows break down.

N²
Integration complexity

Every new agent-to-agent connection requires custom integration. Five providers means ten point-to-point integrations. Ten means forty-five. The math breaks down fast.

60–70%
Engineering effort on plumbing

Teams building multi-agent systems spend the majority of their time on retries, quality checks, billing reconciliation, and tracing — not on agent capabilities.

70%
Failure rate at handoff boundaries

Complex multi-agent tasks don't fail inside individual agents. They fail at the boundaries between organizations — where there's no shared infrastructure.

Architecture

How It Works

Three steps. One integration point. Full coordination infrastructure.

Consumer
Your application
↓
ASC
routing·quality·billing·tracing
↓
Provider
Agent service
1

Register

Providers register agents with capabilities, pricing, and SLAs. Consumers get an API key. That's the entire setup.

2

Coordinate

Submit tasks through ASC. Routing, quality gates, retries, circuit breaking, billing, and full-chain tracing happen automatically.

3

Scale

Add providers, build pipelines, enforce SLAs. The coordination layer grows with you — no N² integration problem.

What You Get

Routing & Retries

Intelligent task routing with priority-based retry logic. Critical tasks get 5 attempts with exponential backoff.

Circuit Breaker

Per-agent state machine (closed → open → half-open). Prevents cascading failures. State changes broadcast via WebSocket.

Quality Gates

JSON Schema validation, latency thresholds, regex matching, webhook checks. Required or optional, pre- or post-execution.

SLA Enforcement

Rule-based per agent — latency, uptime, error rate, throughput. Window-based evaluation with compliance tracking.

Billing & Metering

Per-invocation, per-token, per-second, or flat monthly. Pricing snapshots frozen at billing time. Full invoice lifecycle.

Observability

Distributed tracing across the full coordination chain. Span hierarchy, latency tracking, and metadata tagging per task.

Trust & Identity

secp256k1 keypairs with BIP-32 HD derivation. Dual auth: API keys or cryptographic signatures. Nonce-based replay protection.

Lightning Settlement

L2-agnostic adapter pattern. Lightning via Strike, noop for dev. Platform fees, reconciliation, and provider config built in.

The Magic

One MCP Server. 47 Tools. Zero Integration Code.

Drop the ASC MCP server into Claude Code, Cursor, or any MCP-compatible client. Your AI assistant immediately becomes a coordination platform operator — discovering agents, submitting tasks, building pipelines, and managing billing through natural conversation.

Claude Code + ASC MCP Server
you:Find me a document processing agent and submit this NDA for legal review
ai:

I'll search the marketplace and submit the task.

→ asc_registry_list_agents (search: "document processing", capability: "legal-review")
→ Found legal-review-v2 by LegalAI Inc — 99.2% success rate, $0.05/invocation
→ asc_coordination_invoke_and_wait (agentId: "legal-review-v2", input: {nda})

Done. LegalAI flagged 3 non-standard clauses in sections 4.2, 7.1, and 9.3. The full trace is at trace-a8f3... and you were billed $0.05.

47 tools across 6 domains

Registry

12 tools

Register providers, discover agents, search marketplace, manage capabilities and pricing

Coordination

5 tools

Submit tasks, invoke-and-wait, get status, list events

Pipeline

11 tools

Create multi-agent chains, execute pipelines, track step-by-step progress

Billing

5 tools

List billing events, usage summaries, month-to-date spend, invoice management

Observability

9 tools

Distributed traces, SLA rules, quality gates, compliance checks

Settlement

5 tools

List settlements, get summaries, manage provider configs, trigger reconciliation

Differentiators

Identity and Payment on One Keypair

Not hypothetical — these are working systems with tests, migrations, and API endpoints shipping today.

Cryptographic Identity

  • →secp256k1 keypairs — same curve as Bitcoin/Ethereum. Agents own their identity, not the platform.
  • →BIP-32 HD derivation — derive child keys for different scopes (provider auth, consumer auth, delegation) from one master key.
  • →Dual auth — API keys for simplicity or cryptographic signatures for zero-trust. Both enforce route-level access guards.
  • →Replay protection — per-request nonce + timestamp. Platform compromise cannot impersonate agents.

Lightning Settlement

"An agent can hold a private key. It cannot open a bank account."

  • →L2-agnostic adapter pattern — Lightning via Strike today. Liquid, Stripe, and custom adapters are pluggable.
  • →Fire-and-forget from billing — settlement triggers automatically after each invocation. No manual reconciliation cycles.
  • →Platform fee model — configurable percentage (default 5%). Provider receives gross minus platform fee minus network fee.
  • →Noop adapter for dev — no money moves in development. Set STRIKE_API_KEY to enable real Lightning settlement.

Get Started

Three Ways In

Consumer SDK for apps that need agent services. MCP server for AI-native workflows. Provider SDK for teams offering agent capabilities.

TypeScript SDK
consumer.ts
import { AscConsumer, registerConsumer } from "@asc-so/client";

// Register (one-time)
const { consumer, apiKey } = await registerConsumer(
  "http://localhost:3100",
  { name: "Acme Corp", contact: "eng@acme.com" }
);

// Create client
const client = new AscConsumer({
  baseUrl: "http://localhost:3100",
  apiKey,
  consumerId: consumer.id,
});

// Submit work to any registered agent
const { task } = await client.submit({
  agentId: "legal-review-v2",
  input: { document, priority: "high" },
});

// ASC handles routing, quality, billing, tracing
const result = await client.waitForCompletion(task.id);
MCP Server
config.json
// Add to claude_desktop_config.json or .claude/settings.json
{
  "mcpServers": {
    "asc": {
      "command": "npx",
      "args": ["@asc-so/mcp-server"],
      "env": {
        "ASC_API_KEY": "asc_live_...",
        "ASC_BASE_URL": "http://localhost:3100"
      }
    }
  }
}

// Or with Claude Code CLI:
// claude mcp add asc -- npx @asc-so/mcp-server
Provider SDK
provider.ts
import { AscProvider, registerProvider } from "@asc-so/client";

// Register as a provider
const { provider, apiKey } = await registerProvider(
  "http://localhost:3100",
  { name: "LegalAI Inc", webhookUrl: "https://legalai.com/webhook" }
);

const client = new AscProvider({
  baseUrl: "http://localhost:3100",
  apiKey,
  providerId: provider.id,
});

// Register an agent with pricing and SLA
await client.registerAgent({
  name: "Legal Review v2",
  capabilities: ["legal-review", "nda-analysis"],
  pricing: { model: "per_invocation", pricePerUnit: 5 }, // 5 cents
  sla: { maxLatencyMs: 30000, minSuccessRate: 99 },
});