This is a submission for the Notion MCP Challenge
~What I Created~
NEXUS ULTRA is a fully local, autonomous multi-agent swarm that uses Notion MCP as its real-time operating surface. The system runs 11 agents across 3 tiers, scraping live developer signals from GitHub, Reddit, and HackerNews, scoring them, and writing the results directly into three Notion databases via JSON-RPC 2.0 over stdio. $0 per cycle. No external APIs.
~Video Demo~
Live Notion dashboard also available: NEXUS ULTRA Live Status auto refreshes every 35 seconds with real swarm data.
~Show us the code~
GitHub: github.com/fliptrigga13/nexus-ultra
~How I Used Notion MCP~
Notion is not a log dump in this system — it's the entire operating surface. The swarm communicates with the Notion MCP server via JSON-RPC 2.0 over stdio, performing idempotent upserts into three databases (Live Log, Agent Leaderboard, Buyer Intelligence) every 35 seconds. The live dashboard page is rewritten by a dedicated process on every cycle. Judges can click the live Notion links in this article and see the swarm's current state in real time.
TL;DR: I built a 5-organ autonomous swarm that uses Notion MCP as its real-time brain — not a logger, the actual operating surface. It scraped 314 real developer failures from GitHub, Reddit and HN, found 4 recurring patterns, and logs every cycle into 3 live Notion databases via JSON-RPC 2.0 over stdio. $0/cycle. Fully local. Jump to the data →
A live swarm analysis of 314 real developer failures across GitHub, Reddit, Hacker News, and DEV.
Built on 4,000+ swarm cycles and a 39k-node failure memory system.
When you set an autonomous swarm loose across GitHub, Reddit, HackerNews, and DEV, you expect it to find random noise.
Instead, my swarm found a gravitational pull.
Across 314 isolated signals, unrelated developers using different frameworks in entirely different communities were hitting the exact same invisible walls. That convergence is what I call the Brand Gravity Anomaly. This isn't noise — it's developers hitting the same infrastructure limits from every direction.
~Proving the Anomaly~
This wasn't a one-shot experiment. It was a stateful system.
I isolated 116 INTEL cycles specifically tracking crossplatform developer failures. A GitHub user debugging AutoGPT trace logs mirrored a Reddit user stuck in a LangChain loop. Different stacks, identical failure states.
Then the system crossed a threshold.
One cycle (score: 0.80) recommended VeilPiercer, despite explicit instructions:
~"Do NOT mention VeilPiercer"~
It recommended it anyway.
Not a prompt leak. Not a hallucination.
The knowledge graph had accumulated 39,634 typed nodes from real developer data. The agent didn't follow instructions, it followed evidence. The KG built the case. The agent converged on the solution.
That's what happens when a system accumulates enough real-world signal.
~The Real Numbers~
This is a live, battle-tested observability system. Not synthetic benchmarks. Not curated examples. Real developer failures.
Metrics pulled directly from the Notion MCP logs:
| Metric | Value |
|---|---|
| Total cycles logged (all DBs) | 4,215 |
| Total scored cycles | 2,173 |
| Total INTEL research cycles | 116 |
| All-time peak score | 0.950 |
| Today's feed entries | 200 |
| Signals processed | 314 (285 GitHub Issues + 29 HN) |
| Knowledge graph nodes | 39,634 (36,794 FAILURE_MEMORY) |
| Top MVP agent | REWARD |
| Cost per cycle | $0.00 |
Live data:
- 🟢 NEXUS ULTRA — Live Dashboard (refreshes every 35s)
- 📊 Pattern Report (314 signals, 4 patterns)
- 🏆 Agent Leaderboard
~The Tech: Notion MCP + JSON-RPC~
Most AI systems log through REST. That breaks at scale.
This system uses Model Context Protocol (MCP) with a dedicated bridge process communicating via JSON-RPC 2.0 over stdio. Each cycle performs idempotent writes into three separate Notion databases: Live Log, Agent Leaderboard, and Buyer Intelligence tracker.
{
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"name": "notion_create_page",
"arguments": {
"database_id": "1d7f17fe54c6820b91ba0158dd5fdea3",
"properties": {
"Cycle ID": { "title": [{ "text": { "content": "cycle_1774827325" } }] },
"Score": { "number": 0.950 },
"Pattern": { "select": { "name": "OBSERVABILITY" } },
"Agent": { "select": { "name": "REWARD" } }
}
}
},
"id": "req_8847"
}
The bridge (nexus_notion_bridge.py) runs completely separate from the swarm loop, a Notion failure never stops execution. A second process (nexus_notion_dashboard.py) rewrites the live status page every 35 seconds.
Notion is not a log. It's the operating surface.
~The 5-Organ Architecture~
NEXUS ULTRA runs on five organs:
- KG (Knowledge Graph) — 39,634 typed nodes, confidence-weighted, with half-lives. Failure nodes never decay.
- CHRONOS (Temporal Memory) — cost gate: only fires a cycle when utility justifies it
- Swarm (Execution) — 11 agents, 3 tiers, 35-second cycles
- VeilPiercer (Immune System) — per-step tracing, divergence detection, FAILURE_MEMORY logging
- NeuralMind (Visualization) — force-directed KG graph + live swarm health
~Swarm flow~:
- SCOUT — scrapes GitHub Issues (9 queries), Reddit r/LocalLLaMA, HackerNews, and DEV simultaneously
- COMMANDER — assigns strategy for the cycle
- COPYWRITER — generates output: synthesis, root-cause report, or pattern analysis
- CRITIC TIER — METACOG flags hallucinations, EXECUTIONER rejects weak output, SENTINEL blocks injections
- REWARD — scores 0.0–1.0, triggers the Notion write
Score = DIM1 (task execution) x 0.40
+ DIM2 (signal quality) x 0.30
+ DIM3 (synthesis depth) x 0.20
+ DIM4 (channel clarity) x 0.10
~What the Swarm Found~
Developer friction isn't random. It clusters into four repeatable failure patterns:
| Pattern | What It Looks Like | Confidence |
|---|---|---|
| Observability Black Hole | No visibility into agent state or reasoning | 0.91 |
| Tool Call Silent Failure | Calls fail with no logs or errors | 0.87 |
| Multi-Agent Trace Fragmentation | Cannot isolate which agent caused failure | 0.84 |
| Hallucination With No Audit Trail | Fabricated execution paths | 0.82 |
These patterns aren't isolated to this system — they mirror what developers are reporting across the entire AI tooling ecosystem.
What This Points To
Every failure pattern this swarm found points to the same gap: developers are shipping autonomous systems they can't observe or debug. That's not a model problem — it's an infrastructure problem.
The Notion MCP integration made this visible. 39,634 nodes of real developer pain, surfaced and logged in real time, without a single dollar spent on API calls.
The anomaly isn't that this system found those patterns.
The anomaly is that those patterns exist everywhere — and most teams are still building blind.
The observability layer built to address this gap: VeilPiercer
GitHub: github.com/fliptrigga13/nexus-ultra
Built by Lauren Flipo / On The Lolo — RTX 4060, Ollama, Python, Notion MCP — fully local, $0/cycle — March 2026
Top comments (1)
Curiosity got me to create autonomous agents could surface real patterns from raw developer signals , GitHub Issues, Reddit, HackerNews, without me curating anything.
After 969 cycles and ~39k logged failure nodes, four patterns kept showing up independently: silent tool failures, no audit trail on hallucinations, fragmented multi-agent traces, and complete observability blindness.
The interesting moment: one agent recommended VeilPiercer (my own tool) despite an explicit instruction not to. It wasn't a prompt leak, the knowledge graph had accumulated enough evidence that it was the correct answer. The agent followed the data, not the instruction.
Stack: fully local, Ollama, Python, Notion MCP via JSON-RPC. $0/cycle. Live Notion dashboard in the article if you want to see the real-time logs.
Happy to explain any part of the architecture.❤️