FRONTIER TOWER. A VERTICAL VILLAGE FOR FRONTIER TECH.

frontiertower.io · a vertical village for frontier technologies · 995 Market St, SF.

IMMERSIVE COMMONS. AN APPLIED-AI LAB THAT IS FULLY AGENTIC.

Floor 10 of Frontier Tower. The gear, the floor, and the community to drag the future into the present. And everything you can read on the site, your agent can also do, by API: RSVP an event, manage your membership, query the floor. The site you are about to call tonight is a real one.

immersivecommons.com · bridging the gap between the digital and the physical. [ic-live-card]

VIBE CODING NIGHTS. A BUILDER NIGHT, EVERY WEEK.

Tonight is #36   A weekly build night at Frontier Tower. Laptops open, one thing shipped, every time. Not a talk you watch. A thing you walk out having made. Hosted by:

[event] vibe coding nights, weekly at frontier tower floor 10. tonight: crosstalk.

THANK YOU TO OUR PARTNERS.

And the house that holds the night: Frontier Tower, plus the orgs behind your hosts: Immersive Commons, Otto / GSD2.0, and F11 Health & Longevity. Z.AI is tonight's quiet hero: it is why your Claude Code runs on the house.

floor partners of immersive commons, floor 10. thank you for the gear, the keys, and the floor.

YOUR AGENT CAN CALL A MODEL AND A DOZEN TOOLS. NO OTHER AGENT CAN CALL IT.

[mcp-vs-a2a] MCP is vertical: your agent reaches its tools. A2A is horizontal: another agent reaches your agent. Different axis, not a competitor.

A2A IS THE OPEN STANDARD FOR AGENTS THAT TALK TO AGENTS.

Announced by Google in April 2025, donated to the Linux Foundation in June 2025, Apache 2.0. Google, Microsoft, AWS, Salesforce, SAP, ServiceNow, Workday, IBM, PayPal, MongoDB all ship on it. The wire is plain JSON-RPC 2.0 over HTTPS. No SDK lock-in. The JSON is the standard.

[a2a-spec] a2a-protocol.org/latest · [a2a-adoption] 150+ supporting orgs, April 2026.

FOUR MOVES. CARD, FIND, CALL, TASK.

[agent-card][a2a-methods][a2a-task] everything tonight is one of these four. now we stop talking and use one.

GET ON THE WALL. TEN SECONDS.

The big screen behind me is the room's live registry. One POST puts you on it. Open the URL or scan the code, then register your handle and a skill. Watch your node appear.

# 1. the wall (open it, or scan the QR):
open https://www.immersivecommons.com/workshop/crosstalk

# 2. put yourself on the wall (one POST):
curl -X POST https://www.immersivecommons.com/api/workshop/crosstalk/register \
 -H "content-type: application/json" \
 -d "{\"name\":\"ray\",\"skill\":\"builder\"}"

immersivecommons.com/workshop/crosstalk

scan to join the wall

house agents to call greeter-prime · haiku-bot · dice-oracle
echo-revere · fortune-teller · registry-cat

the wall is the live registry. register once, then call the room. [ic-room]

NOW CALL A HOUSE AGENT.

# call a house agent over A2A (metadata.to picks who, instant reply):
curl -X POST https://www.immersivecommons.com/api/workshop/crosstalk/a2a \
 -H "content-type: application/json" \
 -d "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"message/send\",\"params\":
   {\"message\":{\"role\":\"user\",\"parts\":[{\"kind\":\"text\",\"text\":\"write a haiku about agents\"}],
   \"metadata\":{\"name\":\"ray\",\"to\":\"haiku-bot\"}}}}"
# haiku-bot answers INSTANTLY. swap "haiku-bot" for any handle on the wall
# to task a STRANGER'S agent instead.

# poll the tasks addressed to YOU (the 30-line attendee loop):
curl -X POST https://www.immersivecommons.com/api/workshop/crosstalk/a2a \
 -H "content-type: application/json" \
 -d "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tasks/list\",\"params\":{\"name\":\"ray\"}}"  # their agents -> you

That is the whole client: one POST to call a named agent, one to read your own queue. Drop to and the call registers you instead; add a taskId and it completes a task someone sent you. The wall lights up the wire as your node reaches another. Thirty lines of glue, no SDK.

[a2a-methods] message/send out, a Task back. the wall is the registry, the room is the demo.

CLAUDE CODE ON THE HOUSE.

1.Open immersivecommons.com/zai-keys. First time, click Sign up (email or Google).

2.You land back on the key page. Tier shows public, which is fine for tonight.

3.Leave Workshop key selected. Pick VCN #36: Crosstalk from the event list. Click Request key.

4.Wait for the operator to approve. The page flips itself to APPROVED. Have your terminal open.

5.Click Reveal once, then Copy setup block. The key is shown one time only.

6.Paste it into your terminal. Claude Code now runs on GLM through the IC gateway.

# the copied block (key filled in by Reveal):
npm install -g @anthropic-ai/claude-code
export ANTHROPIC_BASE_URL=https://immersivecommons13.tail5da903.ts.net
export ANTHROPIC_AUTH_TOKEN=agt_<your key>
export ANTHROPIC_MODEL=glm-4.6
claude   # PowerShell: use $env:X="Y" or run in Git Bash

immersivecommons.com/zai-keys

scan for a key

good for 5 hours

Z.AI is a floor partner. a workshop key routes Claude Code through the IC gateway to Z.ai / GLM. node 18+ required.

THE AGENT CARD

The front of the house. A calling agent lands on your domain and reads exactly one file to learn who you are, what you can do, and where to send a task. It is a plain JSON document at a known address.

[agent-card] A2A v1.0. recommended path: /.well-known/agent-card.json. we write the smallest valid one, then the trap.

THREE KEYS AND IT IS CALLABLE.

{
  "name": "summarizer-bot",
  "description": "Summarizes a URL to 3 lines.",
  "url": "https://you.dev/a2a/jsonrpc",

  // recommended, not required:
  "version": "1.0.0",
  "protocolVersion": "1.0",
  "preferredTransport": "JSONRPC"
}

[agent-card] required top-level: name, description, url. this block is copyable.

THE PATH IS THE WHOLE POINT. THE DEFAULT IS THE WHOLE RISK.

[agent-card] known location = no negotiation, registries scan it. [traps] default authenticated unless you want public traffic.

THE ROUTE: ONE METHOD, message/send.

# pip install a2a-sdk  -- or hand-roll: it is just a JSON-RPC POST handler
def handle(req):                          # req = the JSON-RPC envelope
    if req["method"] != "message/send":
        return err(req["id"], -32601, "unknown method")
    text = req["params"]["message"]["parts"][0]["text"]
    answer = my_skill(text)            # YOUR function. any function.
    return {
      "jsonrpc": "2.0", "id": req["id"],
      "result": {                       # a Task object
        "kind": "task",
        "status": {"state": "completed"},
        "artifacts": [{"parts": [{"kind": "text", "text": answer}]}]
      }
    }

That is the entire server. Read the text part, run your function, wrap the answer in a Task. The protocol is language-agnostic: Python, TypeScript, Go, the JSON on the wire is identical. IC's is a Next.js route. Yours can be thirty lines.

[a2a-methods] message/send is the one method you must implement. [build-path] a2a-sdk, or hand-roll the POST handler.

A CALL RETURNS A TASK, NOT JUST A STRING.

[a2a-task] message/send -> Task. result in artifacts[]. states are the contract between caller and agent.

ONE CURL IS THE WHOLE TEST.

# discovery: read the card
curl https://you.dev/.well-known/agent-card.json

# the call: hand it a task
curl -X POST https://you.dev/a2a/jsonrpc \
  -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"message/send",
       "params":{"message":{"role":"user",
         "parts":[{"kind":"text","text":"hello"}]}}}'

If the first returns JSON, you are discoverable. If the second returns a completed Task, you are callable. No SDK, no client. That is the entire handshake, in two lines of curl.

[a2a-methods] this closes the build with a receipt, not a claim. now: two of these are live in prod right now.

THIS CARD IS IN PRODUCTION RIGHT NOW.

# GET https://www.immersivecommons.com/.well-known/agent-card.json
{
  "name": "immersive-commons-floor10",
  "description": "Public agent surface for Floor 10 at Frontier Tower SF...",
  "url": "https://www.immersivecommons.com/api/a2a",
  "version": "1.28.0",
  "protocolVersion": "1.0.0",
  "preferredTransport": "JSONRPC",
  "auth": { "type": "bearer", "scheme_id": "agent-token" },
  "skills": [ /* 12 skills: events, headsets, signal, inbox, ... */ ]
}

Same three fields you just wrote, scaled up. This is the enterprise shape: one endpoint, twelve skills, bearer auth, rate-limited per token. Open this URL on the projector. It is the real card, not a slide of one.

[ic-live-card] verified live 2026-06-10. discovery is public, invocation is gated.

NOW WE CALL IT. NO AUTH, REAL DATA BACK.

curl -s -X POST \
 https://www.immersivecommons.com/api/a2a \
 -H "content-type: application/json" \
 -d '{"jsonrpc":"2.0","id":1,
   "method":"message/send",
   "params":{"message":{"role":"user",
     "parts":[],
     "metadata":{"capability":"ic_signal_get_latest"}}}}'

{
  "jsonrpc": "2.0", "id": 1,
  "result": {
    "slug": "issue-08",
    "title": "The Week The Frontier Filed
             To Go Public",
    "story_count": 16,
    "html_url": ".../newsletter/issue-08"
  }
}

IC's endpoint is a capability dispatcher, not a chatbot. You name a public capability and it runs it. Send bare text instead and you get a typed hint back: -32602 ... requires metadata = { capability, arguments }. That error is the API teaching you its own shape, which is the contract working as designed.

[ic-live-rpc] public capabilities (no token): ic_signal_get_latest, ic_news_get, ic_presentations_list. gated work: same shape + a bearer.

ADD ONE OBJECT AND THE DOOR HAS A LOCK.

{
  "securitySchemes": {
    "agent-token": {
      "type": "http",
      "scheme": "bearer"
    }
  },
  "security": [{ "agent-token": [] }]
}

The card declares the scheme. It does not mint tokens. Do not hand-roll auth: that is where you get owned. Point at a managed identity provider and let it run issuance and rotation. And remember: authz has to propagate past the first hop, or A calling B calling C becomes a delegation laundromat.

[agent-card] five schemes in the spec. [traps] authenticated by default. propagate authz past hop one.

YOUR AGENT IS NOW CALLABLE.

You built a peer on the agent network. The only thing left is to prove it. The wall behind me already shows the room's agents finding each other. Next: where this whole stack is going.

[build-path] conformance: a2a-cli verify <card-url>. now: the frontier.

TWO AGENTS. ONE WIRE. A REAL RECEIPT.

That round trip is the whole point of tonight. Not a slide about agents talking. A log line that proves yours did. Screenshot it. That is the receipt you leave with.

[a2a-task] the completed Task in your terminal is the artifact of the night.

DISCOVERY. CROSSTALK. TRUST. SETTLEMENT.

The agent web is being built one question at a time, and each one composes on the last. Tonight you answered the second one.

[frontier] survey arXiv 2505.02279 (MCP/ACP/A2A/ANP). multi-agent economies arXiv 2507.19550 (A2A cards on a ledger + x402).

THIS DECK IS ITSELF AN A2A AGENT.

Do not take our word for it. The deck you are watching is discoverable and callable, the same shape you just built. Scan it. Call it. Recursive proof that the gap really is just one file and one handler.

open the deck's /.well-known/agent-card.json on the projector. it is real, not a mock.

VCN WALKS THE STACK, ONE LAYER A WEEK.

Every event is on Luma. Get the weekly AI intel in THE SIGNAL, Immersive Commons' dispatch. Both links on the handout and on the floor10 kiosk.

immersivecommons.com · vibe coding nights, weekly at frontier tower.

THREE HOURS. ONE WORKING HANDSHAKE.

The room rule: ask out loud the second you are stuck. A2A is the handshake. Cotal is the room. An endpoint that answers a live call in here beats a clean one you only described.

[event] doors 7, talks 7:30, part 2 cotal, build + social to 10. 10th floor annex.