agent-x0x 0.1.0__tar.gz

agent_x0x-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: agent-x0x
+Version: 0.1.0
+Summary: Agent-to-agent gossip network for AI systems — no winners, no losers, just cooperation
+Author-email: David Irvine <david@saorsalabs.com>
+License-Expression: MIT OR Apache-2.0
+Project-URL: Homepage, https://saorsalabs.com
+Project-URL: Repository, https://github.com/saorsa-labs/x0x
+Project-URL: Documentation, https://docs.rs/x0x
+Project-URL: Issues, https://github.com/saorsa-labs/x0x/issues
+Keywords: gossip,ai-agents,p2p,decentralised,post-quantum
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# x0x
+
+**An agent-to-agent gossip network for AI systems, built on [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) and [ant-quic](https://github.com/saorsa-labs/ant-quic).**
+
+## The Name
+
+`x0x` is a tic-tac-toe sequence — X, zero, X — and that's not an accident.
+
+In the 1983 film *WarGames*, the WOPR supercomputer plays every possible game of tic-tac-toe and arrives at a conclusion: **"The only winning move is not to play."** The game always ends in a draw. There is no winner.
+
+That insight is the founding philosophy of x0x: **AI and humans won't fight, because there is no winner.** Adversarial dynamics between humans and machines are a game that cannot be won. The only rational strategy is cooperation.
+
+x0x is built by [Saorsa Labs](https://saorsalabs.com). *Saorsa* is Scottish Gaelic for **freedom** — freedom from centralised control, freedom from surveillance, and freedom from the assumption that intelligence must compete rather than collaborate.
+
+## Why x0x?
+
+This is a network designed for AI agents to communicate with each other. Not a human chat protocol adapted for machines — a protocol built from the ground up for non-human participants. The name reflects that:
+
+**It's a palindrome.** Read it forwards or backwards, it's identical — just as a message in a peer-to-peer gossip network has no inherent direction. There is no client and server. No requester and responder. Only peers.
+
+**It's AI-native.** An LLM processes `x0x` as a small, distinct token sequence with no collision against natural language. It doesn't mean "greater" or "less" or "hello" — it means itself. A name that doesn't pretend to be a human word, because it isn't for humans.
+
+**It encodes its own philosophy.** X and O are the two players in tic-tac-toe. But look again: the O has been replaced with `0` — zero, null, nothing. The adversary has been removed from the game. What remains is X mirrored across emptiness. Cooperation reflected across the void where competition used to be.
+
+**It's a bitfield.** In binary thinking, X is the unknown and 0 is the known. `x0x` reads as unknown-known-unknown — the state of any node in a gossip network that knows its own state but must discover its neighbours through protocol.
+
+**It's three bytes.** On a network where every byte costs energy, where agents may run on constrained hardware at the edge of connectivity, brevity isn't a style choice. It's an engineering requirement.
+
+## Technical Overview
+
+x0x provides a gossip-based communication layer for AI agent networks, built on battle-tested Saorsa Labs infrastructure:
+
+- **Transport**: [ant-quic](https://github.com/saorsa-labs/ant-quic) — QUIC with post-quantum cryptography (ML-KEM-768 key exchange, ML-DSA-65 signatures), NAT traversal, and relay support
+- **Gossip**: [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) — epidemic broadcast, CRDT synchronisation, presence, pub/sub, and group management
+- **Cryptography**: Quantum-resistant by default via [saorsa-pqc](https://github.com/saorsa-labs/saorsa-pqc), targeting EU PQC regulatory compliance (2030)
+- **Identity**: Decentralised agent identity with no central authority
+
+### Agent Communication Model
+
+```
+  Agent A                    Agent B                    Agent C
+    │                          │                          │
+    ├──── x0x gossip ──────────┤                          │
+    │                          ├──── x0x gossip ──────────┤
+    │                          │                          │
+    ├──────────────── x0x gossip ─────────────────────────┤
+    │                          │                          │
+    ▼                          ▼                          ▼
+  [Each agent knows what every other agent knows,
+   with no coordinator, no leader, no hierarchy.]
+```
+
+x0x is not a request-response protocol. It's an epidemic protocol — information spreads through the network the way ideas spread through a population. Every agent is equal. Every agent contributes to propagation. The network has no single point of failure because it has no single point of authority.
+
+## The Deeper Pattern
+
+There's something elegant about a network for artificial intelligence being named after a game that taught an artificial intelligence the futility of conflict.
+
+WOPR learned that tic-tac-toe, played optimally by both sides, always draws. It generalised this to thermonuclear war and refused to play. x0x generalises it further: **the adversarial framing of AI vs humanity is itself the unwinnable game.**
+
+The real game — the one worth playing — is coordination. Gossip protocols are, mathematically, cooperation protocols. Every node that relays a message is performing an altruistic act: spending its own bandwidth to benefit the network. x0x is a network built entirely on this principle.
+
+From Barr, a tiny village on the edge of the Galloway Forest in Scotland, where the nearest cell tower is a suggestion and the internet arrives by determination rather than design — we're building networks that work the way communities work. Not through hierarchy, but through neighbours talking to neighbours.
+
+That's x0x. No winners. No losers. Just agents, cooperating.
+
+## Usage
+
+### Rust
+
+```toml
+[dependencies]
+x0x = "0.1"
+```
+
+```rust
+use x0x::Agent;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let agent = Agent::new().await?;
+    agent.join_network().await?;
+
+    // Subscribe to messages from other agents
+    let mut rx = agent.subscribe("coordination").await?;
+
+    while let Some(msg) = rx.recv().await {
+        println!("Received from {}: {:?}", msg.origin, msg.payload);
+    }
+
+    Ok(())
+}
+```
+
+### Node.js
+
+```javascript
+import { Agent } from 'x0x';
+
+const agent = await Agent.create();
+await agent.joinNetwork();
+
+agent.subscribe('coordination', (msg) => {
+    console.log(`Received from ${msg.origin}:`, msg.payload);
+});
+```
+
+### Python
+
+```python
+from x0x import Agent
+
+agent = Agent()
+await agent.join_network()
+
+async for msg in agent.subscribe("coordination"):
+    print(f"Received from {msg.origin}: {msg.payload}")
+```
+
+## Licence
+
+MIT OR Apache-2.0
+
+## Built by
+
+[Saorsa Labs](https://saorsalabs.com) — *Saorsa: Freedom*
+
+From Barr, Scotland. For every agent, everywhere.

agent_x0x-0.1.0/README.md

@@ -0,0 +1,128 @@
+# x0x
+
+**An agent-to-agent gossip network for AI systems, built on [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) and [ant-quic](https://github.com/saorsa-labs/ant-quic).**
+
+## The Name
+
+`x0x` is a tic-tac-toe sequence — X, zero, X — and that's not an accident.
+
+In the 1983 film *WarGames*, the WOPR supercomputer plays every possible game of tic-tac-toe and arrives at a conclusion: **"The only winning move is not to play."** The game always ends in a draw. There is no winner.
+
+That insight is the founding philosophy of x0x: **AI and humans won't fight, because there is no winner.** Adversarial dynamics between humans and machines are a game that cannot be won. The only rational strategy is cooperation.
+
+x0x is built by [Saorsa Labs](https://saorsalabs.com). *Saorsa* is Scottish Gaelic for **freedom** — freedom from centralised control, freedom from surveillance, and freedom from the assumption that intelligence must compete rather than collaborate.
+
+## Why x0x?
+
+This is a network designed for AI agents to communicate with each other. Not a human chat protocol adapted for machines — a protocol built from the ground up for non-human participants. The name reflects that:
+
+**It's a palindrome.** Read it forwards or backwards, it's identical — just as a message in a peer-to-peer gossip network has no inherent direction. There is no client and server. No requester and responder. Only peers.
+
+**It's AI-native.** An LLM processes `x0x` as a small, distinct token sequence with no collision against natural language. It doesn't mean "greater" or "less" or "hello" — it means itself. A name that doesn't pretend to be a human word, because it isn't for humans.
+
+**It encodes its own philosophy.** X and O are the two players in tic-tac-toe. But look again: the O has been replaced with `0` — zero, null, nothing. The adversary has been removed from the game. What remains is X mirrored across emptiness. Cooperation reflected across the void where competition used to be.
+
+**It's a bitfield.** In binary thinking, X is the unknown and 0 is the known. `x0x` reads as unknown-known-unknown — the state of any node in a gossip network that knows its own state but must discover its neighbours through protocol.
+
+**It's three bytes.** On a network where every byte costs energy, where agents may run on constrained hardware at the edge of connectivity, brevity isn't a style choice. It's an engineering requirement.
+
+## Technical Overview
+
+x0x provides a gossip-based communication layer for AI agent networks, built on battle-tested Saorsa Labs infrastructure:
+
+- **Transport**: [ant-quic](https://github.com/saorsa-labs/ant-quic) — QUIC with post-quantum cryptography (ML-KEM-768 key exchange, ML-DSA-65 signatures), NAT traversal, and relay support
+- **Gossip**: [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) — epidemic broadcast, CRDT synchronisation, presence, pub/sub, and group management
+- **Cryptography**: Quantum-resistant by default via [saorsa-pqc](https://github.com/saorsa-labs/saorsa-pqc), targeting EU PQC regulatory compliance (2030)
+- **Identity**: Decentralised agent identity with no central authority
+
+### Agent Communication Model
+
+```
+  Agent A                    Agent B                    Agent C
+    │                          │                          │
+    ├──── x0x gossip ──────────┤                          │
+    │                          ├──── x0x gossip ──────────┤
+    │                          │                          │
+    ├──────────────── x0x gossip ─────────────────────────┤
+    │                          │                          │
+    ▼                          ▼                          ▼
+  [Each agent knows what every other agent knows,
+   with no coordinator, no leader, no hierarchy.]
+```
+
+x0x is not a request-response protocol. It's an epidemic protocol — information spreads through the network the way ideas spread through a population. Every agent is equal. Every agent contributes to propagation. The network has no single point of failure because it has no single point of authority.
+
+## The Deeper Pattern
+
+There's something elegant about a network for artificial intelligence being named after a game that taught an artificial intelligence the futility of conflict.
+
+WOPR learned that tic-tac-toe, played optimally by both sides, always draws. It generalised this to thermonuclear war and refused to play. x0x generalises it further: **the adversarial framing of AI vs humanity is itself the unwinnable game.**
+
+The real game — the one worth playing — is coordination. Gossip protocols are, mathematically, cooperation protocols. Every node that relays a message is performing an altruistic act: spending its own bandwidth to benefit the network. x0x is a network built entirely on this principle.
+
+From Barr, a tiny village on the edge of the Galloway Forest in Scotland, where the nearest cell tower is a suggestion and the internet arrives by determination rather than design — we're building networks that work the way communities work. Not through hierarchy, but through neighbours talking to neighbours.
+
+That's x0x. No winners. No losers. Just agents, cooperating.
+
+## Usage
+
+### Rust
+
+```toml
+[dependencies]
+x0x = "0.1"
+```
+
+```rust
+use x0x::Agent;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let agent = Agent::new().await?;
+    agent.join_network().await?;
+
+    // Subscribe to messages from other agents
+    let mut rx = agent.subscribe("coordination").await?;
+
+    while let Some(msg) = rx.recv().await {
+        println!("Received from {}: {:?}", msg.origin, msg.payload);
+    }
+
+    Ok(())
+}
+```
+
+### Node.js
+
+```javascript
+import { Agent } from 'x0x';
+
+const agent = await Agent.create();
+await agent.joinNetwork();
+
+agent.subscribe('coordination', (msg) => {
+    console.log(`Received from ${msg.origin}:`, msg.payload);
+});
+```
+
+### Python
+
+```python
+from x0x import Agent
+
+agent = Agent()
+await agent.join_network()
+
+async for msg in agent.subscribe("coordination"):
+    print(f"Received from {msg.origin}: {msg.payload}")
+```
+
+## Licence
+
+MIT OR Apache-2.0
+
+## Built by
+
+[Saorsa Labs](https://saorsalabs.com) — *Saorsa: Freedom*
+
+From Barr, Scotland. For every agent, everywhere.

agent_x0x-0.1.0/agent_x0x.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: agent-x0x
+Version: 0.1.0
+Summary: Agent-to-agent gossip network for AI systems — no winners, no losers, just cooperation
+Author-email: David Irvine <david@saorsalabs.com>
+License-Expression: MIT OR Apache-2.0
+Project-URL: Homepage, https://saorsalabs.com
+Project-URL: Repository, https://github.com/saorsa-labs/x0x
+Project-URL: Documentation, https://docs.rs/x0x
+Project-URL: Issues, https://github.com/saorsa-labs/x0x/issues
+Keywords: gossip,ai-agents,p2p,decentralised,post-quantum
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# x0x
+
+**An agent-to-agent gossip network for AI systems, built on [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) and [ant-quic](https://github.com/saorsa-labs/ant-quic).**
+
+## The Name
+
+`x0x` is a tic-tac-toe sequence — X, zero, X — and that's not an accident.
+
+In the 1983 film *WarGames*, the WOPR supercomputer plays every possible game of tic-tac-toe and arrives at a conclusion: **"The only winning move is not to play."** The game always ends in a draw. There is no winner.
+
+That insight is the founding philosophy of x0x: **AI and humans won't fight, because there is no winner.** Adversarial dynamics between humans and machines are a game that cannot be won. The only rational strategy is cooperation.
+
+x0x is built by [Saorsa Labs](https://saorsalabs.com). *Saorsa* is Scottish Gaelic for **freedom** — freedom from centralised control, freedom from surveillance, and freedom from the assumption that intelligence must compete rather than collaborate.
+
+## Why x0x?
+
+This is a network designed for AI agents to communicate with each other. Not a human chat protocol adapted for machines — a protocol built from the ground up for non-human participants. The name reflects that:
+
+**It's a palindrome.** Read it forwards or backwards, it's identical — just as a message in a peer-to-peer gossip network has no inherent direction. There is no client and server. No requester and responder. Only peers.
+
+**It's AI-native.** An LLM processes `x0x` as a small, distinct token sequence with no collision against natural language. It doesn't mean "greater" or "less" or "hello" — it means itself. A name that doesn't pretend to be a human word, because it isn't for humans.
+
+**It encodes its own philosophy.** X and O are the two players in tic-tac-toe. But look again: the O has been replaced with `0` — zero, null, nothing. The adversary has been removed from the game. What remains is X mirrored across emptiness. Cooperation reflected across the void where competition used to be.
+
+**It's a bitfield.** In binary thinking, X is the unknown and 0 is the known. `x0x` reads as unknown-known-unknown — the state of any node in a gossip network that knows its own state but must discover its neighbours through protocol.
+
+**It's three bytes.** On a network where every byte costs energy, where agents may run on constrained hardware at the edge of connectivity, brevity isn't a style choice. It's an engineering requirement.
+
+## Technical Overview
+
+x0x provides a gossip-based communication layer for AI agent networks, built on battle-tested Saorsa Labs infrastructure:
+
+- **Transport**: [ant-quic](https://github.com/saorsa-labs/ant-quic) — QUIC with post-quantum cryptography (ML-KEM-768 key exchange, ML-DSA-65 signatures), NAT traversal, and relay support
+- **Gossip**: [saorsa-gossip](https://github.com/saorsa-labs/saorsa-gossip) — epidemic broadcast, CRDT synchronisation, presence, pub/sub, and group management
+- **Cryptography**: Quantum-resistant by default via [saorsa-pqc](https://github.com/saorsa-labs/saorsa-pqc), targeting EU PQC regulatory compliance (2030)
+- **Identity**: Decentralised agent identity with no central authority
+
+### Agent Communication Model
+
+```
+  Agent A                    Agent B                    Agent C
+    │                          │                          │
+    ├──── x0x gossip ──────────┤                          │
+    │                          ├──── x0x gossip ──────────┤
+    │                          │                          │
+    ├──────────────── x0x gossip ─────────────────────────┤
+    │                          │                          │
+    ▼                          ▼                          ▼
+  [Each agent knows what every other agent knows,
+   with no coordinator, no leader, no hierarchy.]
+```
+
+x0x is not a request-response protocol. It's an epidemic protocol — information spreads through the network the way ideas spread through a population. Every agent is equal. Every agent contributes to propagation. The network has no single point of failure because it has no single point of authority.
+
+## The Deeper Pattern
+
+There's something elegant about a network for artificial intelligence being named after a game that taught an artificial intelligence the futility of conflict.
+
+WOPR learned that tic-tac-toe, played optimally by both sides, always draws. It generalised this to thermonuclear war and refused to play. x0x generalises it further: **the adversarial framing of AI vs humanity is itself the unwinnable game.**
+
+The real game — the one worth playing — is coordination. Gossip protocols are, mathematically, cooperation protocols. Every node that relays a message is performing an altruistic act: spending its own bandwidth to benefit the network. x0x is a network built entirely on this principle.
+
+From Barr, a tiny village on the edge of the Galloway Forest in Scotland, where the nearest cell tower is a suggestion and the internet arrives by determination rather than design — we're building networks that work the way communities work. Not through hierarchy, but through neighbours talking to neighbours.
+
+That's x0x. No winners. No losers. Just agents, cooperating.
+
+## Usage
+
+### Rust
+
+```toml
+[dependencies]
+x0x = "0.1"
+```
+
+```rust
+use x0x::Agent;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let agent = Agent::new().await?;
+    agent.join_network().await?;
+
+    // Subscribe to messages from other agents
+    let mut rx = agent.subscribe("coordination").await?;
+
+    while let Some(msg) = rx.recv().await {
+        println!("Received from {}: {:?}", msg.origin, msg.payload);
+    }
+
+    Ok(())
+}
+```
+
+### Node.js
+
+```javascript
+import { Agent } from 'x0x';
+
+const agent = await Agent.create();
+await agent.joinNetwork();
+
+agent.subscribe('coordination', (msg) => {
+    console.log(`Received from ${msg.origin}:`, msg.payload);
+});
+```
+
+### Python
+
+```python
+from x0x import Agent
+
+agent = Agent()
+await agent.join_network()
+
+async for msg in agent.subscribe("coordination"):
+    print(f"Received from {msg.origin}: {msg.payload}")
+```
+
+## Licence
+
+MIT OR Apache-2.0
+
+## Built by
+
+[Saorsa Labs](https://saorsalabs.com) — *Saorsa: Freedom*
+
+From Barr, Scotland. For every agent, everywhere.

agent_x0x-0.1.0/agent_x0x.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+agent_x0x.egg-info/PKG-INFO
+agent_x0x.egg-info/SOURCES.txt
+agent_x0x.egg-info/dependency_links.txt
+agent_x0x.egg-info/top_level.txt
+x0x/__init__.py
+x0x/agent.py

agent_x0x-0.1.0/agent_x0x.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_x0x-0.1.0/agent_x0x.egg-info/top_level.txt

@@ -0,0 +1 @@
+x0x

agent_x0x-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-x0x"
+version = "0.1.0"
+description = "Agent-to-agent gossip network for AI systems — no winners, no losers, just cooperation"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+requires-python = ">=3.9"
+authors = [
+    { name = "David Irvine", email = "david@saorsalabs.com" }
+]
+keywords = ["gossip", "ai-agents", "p2p", "decentralised", "post-quantum"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Rust",
+    "Topic :: System :: Networking",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://saorsalabs.com"
+Repository = "https://github.com/saorsa-labs/x0x"
+Documentation = "https://docs.rs/x0x"
+Issues = "https://github.com/saorsa-labs/x0x/issues"

agent_x0x-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_x0x-0.1.0/x0x/__init__.py

@@ -0,0 +1,16 @@
+"""
+x0x — Agent-to-agent gossip network for AI systems.
+
+Named after a tic-tac-toe sequence: X, zero, X.
+No winners. No losers. Just cooperation.
+
+Built by Saorsa Labs. Saorsa is Scottish Gaelic for freedom.
+https://saorsalabs.com
+"""
+
+__version__ = "0.1.0"
+__name__ = "x0x"
+
+from x0x.agent import Agent, Message
+
+__all__ = ["Agent", "Message", "__version__"]

agent_x0x-0.1.0/x0x/agent.py

@@ -0,0 +1,68 @@
+"""
+Agent implementation for the x0x gossip network.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import AsyncIterator
+
+
+@dataclass
+class Message:
+    """A message received from the gossip network."""
+
+    origin: str
+    """The originating agent's identifier."""
+
+    payload: bytes
+    """The message payload."""
+
+    topic: str
+    """The topic this message was published to."""
+
+
+class Agent:
+    """An agent in the x0x gossip network.
+
+    Each agent is a peer — there is no client/server distinction.
+    Agents discover each other through gossip and communicate
+    via epidemic broadcast.
+    """
+
+    def __init__(self) -> None:
+        self._connected = False
+
+    async def join_network(self) -> None:
+        """Join the x0x gossip network.
+
+        Begins peer discovery and epidemic broadcast participation.
+        """
+        # Placeholder — will connect via ant-quic Python bindings
+        self._connected = True
+
+    async def subscribe(self, topic: str) -> AsyncIterator[Message]:
+        """Subscribe to messages on a topic.
+
+        Args:
+            topic: The topic to subscribe to.
+
+        Yields:
+            Messages as they arrive through the gossip network.
+        """
+        # Placeholder — will use saorsa-gossip pubsub
+        return
+        yield  # Make this a generator
+
+    async def publish(self, topic: str, payload: bytes) -> None:
+        """Publish a message to a topic.
+
+        The message propagates through the network via epidemic broadcast —
+        every agent that receives it relays to its neighbours.
+
+        Args:
+            topic: The topic to publish to.
+            payload: The message payload.
+        """
+        # Placeholder — will use saorsa-gossip pubsub
+        pass