Skip to main content

​
Everything Is an Agent

Svantic’s deepest architectural principle: every application, every service, every tool becomes an agent — by publishing an Agent Card and registering with Svantic. This is not a metaphor. It is a concrete, implemented architecture built on the A2A protocol.

​
The Traditional View: AI as a Feature

Most companies think about AI as something you bolt onto an application: Traditional view: each application gets its own AI integration You embed an LLM call, add a chat window, sprinkle some prompt engineering. Each application gets its own AI integration. There is no shared intelligence. There is no composition. When the scraper team builds an AI feature, the support team can’t use it.

​
The Svantic View: Applications as Agents

Svantic inverts this. The AI is the reasoning layer. Applications connect to it and declare their capabilities: Svantic view: applications connect as agents to an AI reasoning layer Each application becomes an agent by virtue of publishing what it can do. It doesn’t need its own AI. It doesn’t need to understand prompts, models, or chain-of-thought reasoning. It describes its capabilities in a JSON manifest, and Svantic handles the rest.

​
What Makes Something an Agent?

In the A2A protocol, an agent has three properties:

​
1. An Agent Card

A JSON manifest published at /.well-known/agent-card.json. It describes who the agent is, what it can do, and where to reach it: 
{
  "name": "my-inventory-service",
  "description": "Manages product inventory across warehouses",
  "url": "http://inventory:4200/send",
  "version": "1.0.0",
  "capabilities": { "streaming": true },
  "skills": [
    {
      "id": "check_stock",
      "name": "check_stock",
      "description": "Check current stock level for a product",
      "parameters": {
        "type": "object",
        "properties": {
          "product_id": { "type": "string" },
          "warehouse": { "type": "string" }
        },
        "required": ["product_id"]
      }
    },
    {
      "id": "reserve_units",
      "name": "reserve_units",
      "description": "Reserve units of a product for an order"
    }
  ]
}

​
2. An A2A Endpoint

A JSON-RPC 2.0 endpoint (typically at /send) that receives tasks, executes capabilities, and returns results. The Svantic SDK handles all of this automatically.

​
3. Registration

After obtaining a JWT from POST /auth/get_token, call: 
POST https://api.svantic.com/agents/register
Authorization: Bearer <jwt>

{ "agent_type": "inventory", "instance_id": "inv-1", "url": "http://inventory:4200", "tools": [], "mcp_servers": {} }
(client_id / client_secret belong only on /auth/get_token; register returns { ok: true }.) Svantic fetches the agent card from url, discovers the capabilities, creates internal tool proxies, and from that moment on, the AI can invoke check_stock and reserve_units as naturally as any built-in tool.

​
The Thin Layer

The effort required to make an existing service an agent is minimal. Here is a complete example: 
import express from 'express';
import { Agent } from '@svantic/sdk';
import { MeshConnector } from '@svantic/sdk/mesh';

const app = express();
app.use(express.json());

// Your existing business logic
async function check_stock(product_id: string, warehouse?: string) {
    // ... your existing database query ...
    return { product_id, available: 42, warehouse: warehouse ?? 'all' };
}

// The thin agent layer
const agent = new Agent({
    name: 'inventory-service',
    description: 'Product inventory management',
    public_url: 'https://inventory.example.com',
    version: '1.0.0',
});

agent.define_capability({
    name: 'check_stock',
    description: 'Check current stock level for a product',
    parameters: {
        type: 'object',
        properties: {
            product_id: { type: 'string', description: 'Product SKU' },
            warehouse: { type: 'string', description: 'Warehouse ID (optional)' },
        },
        required: ['product_id'],
    },
    handler: async (args) => check_stock(args.product_id as string, args.warehouse as string),
});

agent.expose(app);
app.listen(4200, async () => {
    const mesh = new MeshConnector(agent, {
        svantic_url: process.env.SVANTIC_URL ?? 'https://api.svantic.com',
        client_id: process.env.SVANTIC_CLIENT_ID!,
        client_secret: process.env.SVANTIC_CLIENT_SECRET!,
        deployment_mode: 'hosted',
    });
    await mesh.connect();
});
That’s it. Your inventory service is now an agent. Svantic can ask “how many units of SKU-1234 are in the NYC warehouse?” and invoke check_stock to find out — as part of a larger task like “process this order” that might also involve a payment agent, a shipping agent, and a notification agent. The key insight: you didn’t change your business logic. The check_stock function is exactly the same as before. The agent layer is just a thin wrapper that describes the function to the AI and routes invocations to it.

​
The Mesh at Runtime

When multiple agents are registered, Svantic forms an agent mesh — a dynamic network of capabilities that the AI can compose at runtime: Dynamic agent mesh — Svantic composes capabilities from registered agents at runtime A user asks: “Check if SKU-1234 is in stock, and if so, update the support ticket #5678 with the availability.” Svantic’s planner sees this requires two agents: Inventory (for stock check) and Support (for ticket update). It creates a plan:
  1. Invoke inventory-service:check_stock with product_id=SKU-1234
  2. If available > 0, invoke support-agent:add_comment with the result
The executor runs this plan, making A2A calls to each agent. The agents execute locally and return results. The user gets a single coherent response. No one had to write this workflow. The AI composed it from the declared capabilities.

​
Any Application. Any Language. Any Platform.

Because the A2A protocol is HTTP-based (JSON-RPC 2.0), agents don’t have to be Node.js applications. They don’t have to use the Svantic SDK. Any application that can:
  1. Serve a JSON file at /.well-known/agent-card.json
  2. Accept POST requests at an A2A endpoint
  3. Respond with JSON-RPC 2.0 formatted results
…is a valid A2A agent. The Svantic SDK makes this trivial for Node.js/TypeScript applications, but a Python Flask app, a Go service, or even a serverless function can be an agent.

​
Why This Matters

​
Composability

Instead of building point-to-point integrations between services, each service declares what it can do. The AI composes workflows dynamically. New service? Register it. The AI immediately knows how to use it in combination with everything else.

​
Data Sovereignty

Capabilities execute on the agent’s machine. Svantic never sees your data, credentials, or internal state. It only sees the capability description and the result you choose to return. This is critical for regulated industries.

​
Incremental Adoption

You don’t need to rewrite anything. Start with one service. Wrap it in 5 lines. Register it. See results. Then wrap another service. And another. Each new agent makes the mesh more capable. The investment compounds.

​
The Compounding Effect

Every execution feeds the knowledge store. Knowledge from one agent’s domain helps other agents. The scraper learned that insurance portals have a “My Documents” tab? That knowledge helps when the AI encounters a similar portal through a different agent. The mesh gets smarter as a whole, not just individually.