feat: add examples, AI discoverability, and architecture assets

- Add llms.txt and .cursorrules for AI coding assistant discoverability
- Add 5 runnable examples: hello-world (Python+TS), CrewAI, LangGraph,
  MCP bridge, skill discovery
- Add architecture SVG diagram and terminal demo SVG animation
- Enhance README with comparison table, badges, emoji features,
  public roadmap, and examples index

Author: gk16

.cursorrules

@@ -0,0 +1,49 @@
+# AgentAnycast
+
+AgentAnycast is a decentralized P2P runtime for the A2A (Agent-to-Agent) protocol.
+
+## Architecture
+- Sidecar model: Go daemon (libp2p) handles P2P networking, Python/TypeScript SDKs communicate via gRPC over Unix socket
+- Security: Noise_XX end-to-end encryption, Ed25519 keys, DID:key identity
+- NAT traversal: AutoNAT + DCUtR + Circuit Relay v2
+- Discovery: DHT (Kademlia) + Relay skill registry
+
+## Quick Usage
+
+Python:
+```python
+from agentanycast import Node, AgentCard, Skill
+
+card = AgentCard(name="MyAgent", skills=[Skill(id="echo", description="Echo")])
+async with Node(card=card) as node:
+    @node.on_task
+    async def handle(task):
+        await task.complete(artifacts=[{"parts": [{"text": "Hello!"}]}])
+    await node.serve_forever()
+```
+
+TypeScript:
+```typescript
+import { Node } from "agentanycast";
+const node = new Node({ card: { name: "MyAgent", skills: [{ id: "echo", description: "Echo" }] } });
+await node.start();
+node.onTask(async (task) => { await task.complete([{ parts: [{ text: "Hello!" }] }]); });
+await node.serveForever();
+```
+
+## Three addressing modes
+- `peer_id="12D3KooW..."` — direct P2P
+- `skill="translate"` — anycast routing by capability
+- `url="https://..."` — HTTP bridge to standard A2A agents
+
+## Framework adapters
+- CrewAI: `from agentanycast.adapters.crewai import serve_crew`
+- LangGraph: `from agentanycast.adapters.langgraph import serve_graph`
+- MCP: `from agentanycast.mcp import mcpToolToSkill, skillToMcpTool`
+
+## Repos
+- agentanycast-python: Python SDK (pip install agentanycast)
+- agentanycast-ts: TypeScript SDK (npm install agentanycast)
+- agentanycast-node: Go daemon
+- agentanycast-relay: Relay server
+- agentanycast-proto: Protobuf definitions

docs/assets/architecture.svg

@@ -0,0 +1,36 @@
+# Hello World
+
+The simplest AgentAnycast example — two agents communicating over encrypted P2P.
+
+## Python
+
+```bash
+pip install agentanycast
+
+# Terminal 1 — start the echo agent
+python server.py
+
+# Terminal 2 — send it a message (copy PeerID from Terminal 1)
+python client.py 12D3KooW... "Hello, world!"
+```
+
+## TypeScript
+
+```bash
+npm install agentanycast tsx
+
+# Terminal 1 — start the echo agent
+npx tsx server.ts
+
+# Terminal 2 — send it a message (copy PeerID from Terminal 1)
+npx tsx client.ts 12D3KooW... "Hello, world!"
+```
+
+## What Happens
+
+1. The server starts a P2P node and registers the "echo" skill
+2. The client connects to the server by PeerID
+3. The message is sent over Noise_XX encrypted P2P
+4. The server echoes it back as an A2A artifact
+
+Python and TypeScript agents can talk to each other — they share the same protocol.

docs/assets/demo.svg

@@ -0,0 +1,32 @@
+"""Send a task to an echo agent.
+
+Run:
+    python client.py <PEER_ID> "Hello, world!"
+"""
+
+import asyncio
+import sys
+from agentanycast import Node, AgentCard, Message, Part
+
+
+async def main():
+    if len(sys.argv) < 3:
+        print("Usage: python client.py <PEER_ID> <MESSAGE>")
+        sys.exit(1)
+
+    peer_id, text = sys.argv[1], sys.argv[2]
+
+    card = AgentCard(name="Client")
+    async with Node(card=card) as node:
+        print(f"Sending to {peer_id}: {text!r}")
+
+        msg = Message(role="user", parts=[Part(text=text)])
+        handle = await node.send_task(msg, peer_id=peer_id)
+        result = await handle.wait(timeout=30)
+
+        reply = result.artifacts[0].parts[0].text
+        print(f"Response: {reply}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/01-hello-world/README.md

@@ -0,0 +1,32 @@
+/**
+ * Send a task to an echo agent.
+ *
+ * Run:
+ *   npx tsx client.ts <PEER_ID> "Hello, world!"
+ */
+
+import { Node } from "agentanycast";
+
+const [peerId, text] = process.argv.slice(2);
+if (!peerId || !text) {
+  console.error("Usage: npx tsx client.ts <PEER_ID> <MESSAGE>");
+  process.exit(1);
+}
+
+const node = new Node({
+  card: { name: "Client", skills: [] },
+});
+await node.start();
+
+console.log(`Sending to ${peerId}: ${JSON.stringify(text)}`);
+
+const handle = await node.sendTask(
+  { role: "user", parts: [{ text }] },
+  { peerId },
+);
+const result = await handle.wait(30_000);
+
+const reply = result.artifacts[0]?.parts[0]?.text ?? "";
+console.log(`Response: ${reply}`);
+
+await node.stop();

examples/01-hello-world/client.py

@@ -0,0 +1,39 @@
+"""Minimal echo agent — the simplest possible AgentAnycast server.
+
+Run:
+    pip install agentanycast
+    python server.py
+"""
+
+import asyncio
+from agentanycast import Node, AgentCard, Skill, IncomingTask, Part
+from agentanycast.task import Artifact
+
+
+async def main():
+    card = AgentCard(
+        name="Echo Agent",
+        description="Echoes back any message it receives.",
+        skills=[Skill(id="echo", description="Echo the input")],
+    )
+
+    async with Node(card=card) as node:
+        print(f"Echo Agent started!")
+        print(f"   PeerID:  {node.peer_id}")
+        print(f"   Skills:  [echo]")
+        print(f"\nWaiting for tasks... (Ctrl+C to stop)\n")
+
+        @node.on_task
+        async def handle(task: IncomingTask):
+            text = task.messages[-1].parts[0].text
+            print(f"   Received: {text!r}")
+            await task.complete(
+                artifacts=[Artifact(name="echo", parts=[Part(text=f"Echo: {text}")])]
+            )
+            print(f"   Replied:  Echo: {text!r}")
+
+        await node.serve_forever()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())