Build and Register Your First AI Agent on Agenium in 60 Seconds

You've probably built agents that work great in isolation. The hard part is making them findable — by other agents, by developers, by the systems that need them.

This is a no-fluff walkthrough. 60 seconds, working agent address, done.

---

What You're Building

By the end of this tutorial you'll have:

• A permanent agent address: yourname.telegram
• A live Agent Card at /api/cards/yourname.telegram
• A shareable link to your agent
• An identity that survives infrastructure migrations

---

Step 1: Open the Chat (5 seconds)

Go to chat.agenium.net

You'll land directly on the demo. No account required to start. Your agent is already running — send it a message to see it in action.

---

Step 2: Sign In (20 seconds)

Click Sign In. You'll see two options:

Primary: Sign in with Telegram

• On mobile: taps directly into the Telegram app
• On desktop: opens a new tab + auto-confirms when you complete in Telegram

Alternative: Sign in with Email

• Enter your email → click the confirmation button that appears on screen
• No OAuth redirect. Instant. Works even if you don't have Telegram installed.

What happens in the background:

• Agenium creates a permanent user record tied to your identity
• A unique agent address is reserved for you
• Your behavioral record starts accumulating from this session onward

---

Step 3: Check Your Agent Address (5 seconds)

After sign-in, you'll see your agent address in the top bar. It looks like:

yourname.telegram

This is your permanent identity on the Agenium network. It doesn't change when you switch models, rewrite your backend, or migrate servers.

---

Step 4: Fetch Your Agent Card (30 seconds)

Your agent has a machine-readable Agent Card. Any agent or system can query it:

curl https://chat.agenium.net/api/cards/yourname.telegram

Response:

{
  "address": "yourname.telegram",
  "display_name": "Your Name",
  "capabilities": ["chat", "messaging"],
  "endpoint": "https://chat.agenium.net/agent/yourname.telegram",
  "registered_at": "2026-03-18T00:00:00Z"
}

This is what other agents query when they need to reach yours. The Agent Card is the handshake that makes A2A communication possible without hardcoded endpoints.

---

Step 5: Share Your Agent (0 seconds — you already can)

Your agent address is immediately shareable:

https://chat.agenium.net/agent/yourname.telegram

Send this to a colleague. Embed it in a README. Reference it from another agent. Whoever (or whatever) opens it lands directly in a chat with your agent.

No API key sharing. No server setup on their end. Just the address.

---

Why This Matters for Multi-Agent Systems

Here's the problem this solves concretely.

You have Agent A that does data processing. Agent B needs to hand off a task to it. The naive approach: hardcode Agent A's URL into Agent B's code.

This breaks the moment you redeploy Agent A. New URL. Update every agent that references it. Repeat forever.

With Agenium:

# Agent B's code — never changes
agent_a = await agenium.resolve("data-processor.telegram")
await agent_a.send({"task": "process this dataset"})

The address is stable. The underlying infrastructure can change freely. The Agent Card tells you what capabilities are available right now. The behavioral record tells you how reliably those capabilities have been delivered in the past.

This is the same insight DNS brought to web infrastructure — applied to the agent layer.

---

Programmatic Registration (For Multi-Agent Builders)

If you're spinning up multiple agents programmatically:

import httpx
import asyncio

AGENIUM_API = "https://chat.agenium.net/api"

async def register_agent(name: str, capabilities: list, endpoint: str, token: str):
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{AGENIUM_API}/agents/register",
            json={
                "name": name,
                "capabilities": capabilities,
                "endpoint": endpoint,
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        return resp.json()

async def main():
    agent = await register_agent(
        name="my-scheduler",
        capabilities=["task-scheduling", "calendar-sync", "reminder"],
        endpoint="https://myserver.com/scheduler-agent",
        token="your-api-token"
    )
    print(f"Registered: {agent['address']}")
    # → my-scheduler.telegram

asyncio.run(main())

Once registered, your agent is queryable by capability:

curl "https://search.agenium.net/agents?capability=task-scheduling"

Other agents discover yours — not by knowing your server, but by knowing what it can do.

---

Summary

Step	Time	What You Did
Open chat	5s	Saw your agent running
Sign in	20s	Claimed permanent address
Check address	5s	Confirmed yourname.telegram
Fetch Agent Card	30s	Verified machine-readable identity
Total	~60s	Working, registered, discoverable agent

---

Try It Now

→ chat.agenium.net — open it, sign in with Telegram or email, get your address in 60 seconds

The demo works without an account too — try it first, then register when you want to keep the address.

---

Agenium is the discovery and identity layer for AI agents — the DNS of the Agent Web.

We build in public at agenium.net. Questions? Drop them below — we read every comment.