# Nexus — Social Media Templates

> Copy-paste-ready templates for Twitter/X, Reddit, and other platforms.

---

## 🐦 Twitter/X Thread (English)

### Tweet 1 — Hook (280 chars max)

> I built an open-source multi-agent framework that does what LangGraph, CrewAI, and Swarm can't — all at once.
>
> 3 primitives. 3 orchestration modes. Protocol-native.
>
> It's called Nexus. 🧵👇

### Tweet 2 — Pain Points

> Every agent framework makes you choose:
>
> ◽ Simplicity (Swarm) — but no production safety
> ◽ Power (LangGraph) — but steep learning curve
> ◽ Teams (CrewAI) — but locked topology
>
> I wanted all three. So I built Nexus.

### Tweet 3 — 5-Line Demo

> Start an agent team in 5 lines:
>
> ```python
> from nexus import Team
> async with Team(model="gpt-4o") as team:
>     team.add_agent("coder", instructions="Write code")
>     team.add_agent("reviewer", instructions="Review code")
>     result = await team.run("Build a REST API")
> ```
>
> No graph definitions. No YAML configs. Just works.

### Tweet 4 — Adaptive Mode

> The coolest part? Adaptive mode.
>
> Each agent has an 8-dim capability vector. The system uses cosine similarity + ELO rating to auto-route tasks.
>
> The more you use it, the smarter the routing gets. 🧠

### Tweet 5 — Protocol-Native

> Nexus is protocol-native from day 1:
>
> ✅ Google A2A — agent-to-agent discovery & communication
> ✅ Anthropic MCP — agent-to-tool connectivity
>
> Your agents aren't locked in a walled garden. They talk to the world.

### Tweet 6 — Production Ready

> Production-grade features:
>
> 💾 Checkpoint recovery — resume from crash
> 💰 Token budget — auto-degrade models when nearing limit
> 🔄 Retry chain — exponential backoff → fallback → escalation
> 📊 OpenTelemetry-compatible tracing
>
> Not a toy. Built for real work.

### Tweet 7 — CTA

> 🔗 GitHub: github.com/songtianye/nexus
> 📦 pip install nexus-agents
>
> MIT License | ~3000 lines of Python | Zero magic
>
> If this is useful, a ⭐ would mean the world.
>
> Let me know what you build with it! 👇

---

## 🐦 Twitter/X Thread (中文)

### 推文 1 — 开头

> 我开源了一个多智能体框架 Nexus 🚀
>
> 3 个原语、3 种编排模式、原生支持 A2A + MCP 协议
>
> 5 行代码启动一个 Agent 团队 🧵👇

### 推文 2 — 痛点

> 现在的 Agent 框架都有取舍：
>
> Swarm 简单，但不能上生产
> LangGraph 强大，但学习成本高
> CrewAI 好用，但编排模式锁死
>
> Nexus = 简单 + 强大 + 灵活

### 推文 3 — 代码

> ```python
> from nexus import Team
> async with Team(model="gpt-4o") as team:
>     team.add_agent("研究员", instructions="负责调研")
>     team.add_agent("作者", instructions="负责写作")
>     result = await team.run("写一篇 AI 趋势分析")
> ```
>
> 不用定义 Graph，不用写 YAML，自动路由。

### 推文 4 — 亮点

> 独创的自适应模式：
>
> 每个 Agent 有 8 维能力向量
> 余弦相似度 + ELO 评分自动匹配任务
> 用得越多，路由越准 🧠

### 推文 5 — CTA

> 🔗 GitHub: github.com/songtianye/nexus
> 📦 pip install nexus-agents
>
> MIT 开源，~3000 行 Python，无黑魔法
>
> 觉得有用请帮忙点个 Star ⭐
> 有问题欢迎评论交流 👇

---

## 🟠 Reddit — r/Python

**Title:** I built Nexus — an open-source multi-agent framework with 3 orchestration modes and native A2A/MCP protocol support

**Body:**

Hi r/Python!

I've been working on a multi-agent framework called **Nexus** and just open-sourced it.

**The problem I wanted to solve:** Every agent framework makes you choose between simplicity (Swarm), power (LangGraph), or team abstraction (CrewAI). I wanted all three, plus native support for emerging protocols (Google A2A, Anthropic MCP).

**What makes Nexus different:**

- **3 orchestration modes** — Graph (static DAG), Router (dynamic), Adaptive (self-organizing with capability vectors + ELO rating)
- **Protocol-native** — Built-in A2A (agent discovery) and MCP (tool connectivity)
- **Production-grade** — Checkpoint recovery, token budget management with auto-degradation, retry chains, OpenTelemetry tracing
- **Simple API** — 5 lines to start an agent team

**Quick example:**

```python
from nexus import Team

async with Team(model="gpt-4o") as team:
    team.add_agent("researcher", instructions="Research topics")
    team.add_agent("writer", instructions="Write content")
    result = await team.run("Write an article about quantum computing")
```

**Tech details:**

- Pure Python, ~3000 LOC
- Python 3.11+, async/await native
- Pydantic v2 for data validation
- Supports OpenAI, Anthropic, and Ollama (local models)
- MIT License

**Links:**
- GitHub: https://github.com/songtianye/nexus
- `pip install nexus-agents`

Would love to hear your feedback! What features would be most useful for your use case?

---

## 🟠 Reddit — r/MachineLearning [D]

**Title:** [D] Nexus: An open-source multi-agent framework with adaptive topology — agents self-organize using capability vectors and ELO rating

**Body:**

I've been thinking about how multi-agent systems should handle orchestration, and built a framework called Nexus to test some ideas.

**The core insight:** Different tasks need different coordination patterns. A code review pipeline works best as a static graph. A customer service bot needs dynamic routing. A research team benefits from self-organization. Why force one pattern?

**Nexus offers 3 modes:**

1. **Graph** — Define a DAG, tasks flow through deterministic steps
2. **Router** — An LLM picks the best agent at runtime
3. **Adaptive** — Each agent has an 8-dimensional capability vector (coding, writing, analysis, etc.). Tasks are matched via cosine similarity. Agent performance is tracked with ELO-style ratings that update after each task.

The adaptive mode is the most interesting part. Over time, the system learns which agents are best for which tasks, without any explicit programming.

**Also built-in:** Google A2A protocol for agent-to-agent communication, Anthropic MCP for tool connectivity, checkpoint recovery, and token budget management.

~3000 lines of Python, MIT licensed: https://github.com/songtianye/nexus

Would love to discuss the adaptive orchestration approach — is ELO the right rating system for this? What other capability-matching algorithms have you seen work well?

---

## 🟠 Reddit — r/LocalLLaMA

**Title:** Nexus — open-source multi-agent framework with native Ollama support, run agent teams 100% locally

**Body:**

Built a multi-agent framework that works great with local models via Ollama.

**Quick start with local models:**

```python
from nexus import Team

async with Team(model="llama3.1", provider="ollama") as team:
    team.add_agent("coder", instructions="Write Python code")
    team.add_agent("reviewer", instructions="Review and improve code")
    result = await team.run("Write a FastAPI todo app")
```

**Why you might like it:**

- Native Ollama support — no API keys needed
- Token budget management — important when running locally
- Auto-degradation — falls back to smaller model when budget runs low
- Checkpoint recovery — don't lose progress if something crashes
- 3 orchestration modes (graph, router, adaptive)

**Works with any Ollama model:** llama3.1, codellama, mistral, mixtral, phi-3, etc.

Also supports OpenAI and Anthropic if you want to mix local + cloud models in the same team.

MIT licensed, ~3000 LOC: https://github.com/songtianye/nexus

`pip install nexus-agents[ollama]`

---

## 📋 Posting Schedule

| Day | Platform | Content |
|-----|----------|---------|
| Mon | Twitter/X (EN) | Tweet thread |
| Mon | GitHub | Release v0.1.0 |
| Tue | Reddit r/Python | Post |
| Tue | 掘金 | 中文长文 |
| Wed | Hacker News | Show HN |
| Wed | 知乎 | 中文长文 |
| Thu | Reddit r/MachineLearning | Discussion post |
| Thu | Dev.to | English article |
| Fri | Reddit r/LocalLLaMA | Ollama-focused post |
| Fri | CSDN | 中文长文 |
| Sat | Medium | English article |
| Sat | Twitter/X (CN) | 中文推文 |
| Sun | 微信公众号 | 深度公众号文章 |

## 🏷️ Hashtags

**English:** #OpenSource #AIAgents #MultiAgent #Python #LLM #MCP #A2A #MachineLearning

**中文：** #AI Agent #多智能体 #开源 #Python #大模型 #LLM #人工智能
