DEV Community: fliptrigga13

The Brand Gravity Anomaly: Uncovering AI Developer Friction with a 5-Organ Swarm and Notion MCP

fliptrigga13 — Mon, 30 Mar 2026 03:41:35 +0000

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

NEXUS ai autonomous

fliptrigga13 — Sat, 28 Mar 2026 20:31:07 +0000

NEXUS ULTRA is a fully autonomous AI swarm that runs 24/7 on your local hardware, no cloud, no API costs. 11 agents collaborate every cycle: scouting the web, writing copy, critiquing each other, and scoring themselves. Every cycle gets logged to Notion automatically via MCP. It's been running for weeks without human intervention.

I made a 60-second demo showing exactly how silent agent divergence works

fliptrigga13 — Fri, 27 Mar 2026 14:34:04 +0000

https://github.com/fliptrigga13/VEILPIERCER

I Hooked My Autonomous AI Outreach Swarm to Notion via MCP - It Reports Every Cycle in Real-Time

fliptrigga13 — Thu, 26 Mar 2026 14:39:22 +0000

🤖 NEXUS ULTRA — A fully autonomous AI swarm running 24/7 on local hardware. 11 agents collaborate every cycle: scouting Reddit/HN, writing copy, critiquing each other, and logging every cycle to Notion via MCP. 1,885+ cycles. Zero cloud calls. $0/cycle.

Submission for the Notion MCP Challenge.

What I Built

NEXUS → Notion MCP Bridge: a Python client that connects an autonomous AI outreach swarm to a Notion database using the official @notionhq/notion-mcp-server over stdio transport — no REST API, pure Model Context Protocol.

Every 90 seconds, the swarm runs a cycle: scrape a live Reddit thread, write a reply, score it 0.0–1.0. Every passing cycle becomes a Notion database page automatically, giving me a real-time command center to review AI-generated content before it goes live.

GitHub: https://github.com/fliptrigga13/nexus-notion-mcp

The Problem

I run an autonomous outreach swarm that generates Reddit replies for my AI monitoring product. The swarm runs overnight. By morning I had a JSON file with 200 entries and no way to review them at a glance.

Notion was the obvious answer — a queryable, filterable view with a checkbox to track what was posted. The question was how to connect them.

How the Notion MCP Bridge Works

The key design decision: use the official Notion MCP server as the transport layer, not the REST API directly.

AI Swarm (Python) → cycles.json → MCP Bridge → notion-mcp-server (stdio) → Notion DB

The bridge spawns notion-mcp-server as a subprocess and communicates over stdin/stdout using JSON-RPC 2.0:

class NotionMCPClient:
    def start(self):
        env = {**os.environ, "NOTION_API_KEY": self._api_key}
        self._proc = subprocess.Popen(
            ["notion-mcp-server", "--transport", "stdio"],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            env=env,
            text=True,
        )
        self._initialize()

    def _initialize(self):
        self._send({
            "jsonrpc": "2.0",
            "id": self._next_id(),
            "method": "initialize",
            "params": {
                "protocolVersion": "2024-11-05",
                "capabilities": {},
                "clientInfo": {"name": "nexus-notion-mcp-bridge", "version": "1.0"},
            },
        })

Once initialized, the bridge calls notion_create_page for each new cycle:

def create_page(self, database_id: str, cycle: dict) -> bool:
    resp = self._send({
        "jsonrpc": "2.0",
        "id": self._next_id(),
        "method": "tools/call",
        "params": {
            "name": "notion_create_page",
            "arguments": {
                "parent": {"database_id": database_id},
                "properties": {
                    "Name": {"title": [{"text": {"content": title}}]},
                    "Score": {"number": score},
                    "Posted": {"checkbox": posted},
                    "Timestamp": {"date": {"start": ts}},
                },
                "children": [body_block]
            },
        },
    })
    return resp and not resp.get("error")

The Notion Database

Each row captures the full cycle: score, whether it was posted, timestamp, thread context, and the full outreach copy in the page body. The database becomes a live review queue — filter by Posted = false, sort by Score descending.

Setup

npm install -g @notionhq/notion-mcp-server

export NOTION_API_KEY=your_token
export NOTION_DATABASE_ID=your_db_id

python nexus_notion_mcp_bridge.py          # continuous polling
python nexus_notion_mcp_bridge.py --once   # sync once and exit

Why MCP Instead of REST

The REST API would have worked. But using the MCP server as the transport layer means:

Any MCP-compatible AI client can now interact with the same Notion workspace
The bridge is swappable — swap notion-mcp-server for any other MCP server and the Python client stays the same
The stdio transport keeps everything local — no HTTP overhead, no additional auth surface

The MCP protocol is the right abstraction for AI-to-tool communication. The swarm is an AI system, Notion is the tool, MCP is the protocol that connects them.

What's Next

Add notion_update_page when a cycle gets posted to sync the checkbox back
Build a filter view surfacing only high-scoring unposted entries
Connect the REFLECT agent's insights to a Notion notes page

GitHub: https://github.com/fliptrigga13/nexus-notion-mcp

My 11-Agent AI Swarm Was Secretly Hallucinating. My Own Monitoring Tool Caught It.

fliptrigga13 — Thu, 26 Mar 2026 12:51:10 +0000

I built an 11-agent swarm to write Reddit outreach for my product. It ran for weeks. It was hallucinating usernames the entire time — and I didn't notice until I ran a session diff comparing it to a 3-agent rewrite.

This is what the diff showed me, and why I think most multi-agent systems have the same problem.

The Setup

The old system — call it V1 — was an 11-agent blackboard architecture:

COMMANDER → SCOUT → CONVERSION_ANALYST → COPYWRITER → 
METACOG → EXECUTE → EVIDENCE_CHECK → SENTINEL → 
EXECUTIONER → VALIDATOR → ARBITER

Each agent read the shared blackboard, added its output, and passed it forward. Architecturally, it looked impressive. In practice, each agent was doing one of two things:

Restating what the previous agent said
Inventing context that wasn't there

The worst part: it had explicit directives saying never fabricate Reddit usernames. The directives were right there in the prompt, importance score 9.9 out of 10.

It hallucinated usernames anyway. Every cycle.

What the Session Diff Showed

VeilPiercer captures every step a pipeline takes — what it read, what it produced, timing — and lets you compare two runs side by side.

Here's the V1 (Session B, 11 steps) vs V3 (Session A, 3 steps) diff at step 0:

V1 — SCOUT output (step 2, after 38,900ms):

u/techsolo posted: "Been battling with agent divergence again. 
Prometheus alerts are great, but when I need to trace back to 
understand why it happened, I'm lost..."

u/techsolo is fabricated. There was no u/techsolo in the live data. The agent invented a realistic-sounding username and a realistic-sounding quote, and every subsequent agent treated it as ground truth.

V1 — EXECUTIONER output (step 6):

"u/techsolo, looking at the challenges you face with AI agent 
divergence and the need for better observability tools, I 
recommend considering VeilPiercer..."

An outreach message — addressed to a user who doesn't exist — ready to post.

V3 — COPYWRITER output (step 1, after 2,800ms):

One thing that bites a lot of agent setups at scale is silent 
divergence between steps. By the time something breaks, the issue 
happened 3-5 steps earlier when agents silently diverged. 
VeilPiercer captures what each step READ vs what it PRODUCED...

No username. Grounded in a real thread. Took 3 steps and 2.8 seconds.

Why Multi-Agent Cascades Hallucinate More, Not Less

The intuition behind multi-agent systems is: more checks = more reliability. More reviewers = better output.

That intuition is wrong in LLM pipelines.

When you chain 11 agents through a shared blackboard, each agent reads the previous agent's output as if it were ground truth. If step 2 invents a username, step 3 builds on it. By step 8, the hallucination is load-bearing.

The session diff makes this visible in a way logs can't. You can see exactly which step introduced the fabricated context, and watch every downstream step faithfully repeat it.

V1 had a SENTINEL agent specifically designed to catch this. Here's what it output:

[SENTINEL_MAGNITUDE]: [SCOUT]: u/techsolo, I've been following 
your discussion about AI agent divergence...

The sentinel was summarizing the violation — using the fabricated username — as evidence that the pipeline was working.

The Fix: 3 Deterministic Steps

V3 dropped the blackboard entirely:

SCRAPER (pure Python) → COPYWRITER (llama3.1:8b) → REWARD (llama3.1:8b)

SCRAPER: No LLM. Fetches live Reddit JSON, scores threads by keyword density, returns the highest-scoring real thread. If nothing scores above 0, it skips the cycle. No fallback. No fabrication.

COPYWRITER: Single LLM call with the real thread as context. Hardcoded bans: no usernames, no price mentions, no first-person invented experience, no AI-tell openers.

REWARD: Single LLM call scoring 0.0–1.0. Gate at 0.65. If it doesn't pass, the cycle is discarded.

V1 averaged below 0.40 on the same scoring rubric. V3 averages 0.80+.

What the Session Diff Actually Tells You

The useful thing isn't that V3 is "better." The useful thing is that the diff showed me where V1 broke down — and it wasn't where I expected.

I expected the problem to be in the COPYWRITER. It wasn't. The problem was in step 2, SCOUT, when it read low-signal thread data and invented a user to fill the gap. Everything after that was downstream hallucination.

This is the reproducibility problem in a concrete form: two pipelines given the same directive produce completely different behavior, and you can't see why without inspecting what each step read vs what it produced.

The diff surfaced that in one comparison. No added logging. No instrumentation changes.

The Thing Worth Noting

The V1 system was more expensive to run, slower (11 steps vs 3), and produced worse output. The complexity wasn't buying reliability — it was buying a longer hallucination chain.

Most LLM pipelines I've seen have a version of this. The multi-agent architecture gives the illusion of validation. But if each validator is an LLM reading LLM output, you're not adding oversight — you're adding amplification.

The session diff is how you find that out before it matters.

VeilPiercer is the per-step tracing tool I built for local Ollama pipelines. It captures what each step reads and produces, lets you diff sessions, and runs fully offline. veil-piercer.com

I Built an Autonomous AI Outreach Swarm — Now It Reports to Notion in Real-Time

fliptrigga13 — Thu, 26 Mar 2026 01:07:27 +0000

My submission for the Notion MCP Challenge

What I Built

NEXUS Ultra is an autonomous AI agent swarm that runs 24/7 on my local machine, hunting for high-intent developer conversations on Reddit, drafting targeted outreach copy, and scoring its own output — all without cloud APIs or human prompting.

Every cycle the swarm:

Scrapes Reddit for threads matching specific pain signals (agent debugging, LLM observability)
Runs 8+ specialized agents (SCOUT → COMMANDER → COPYWRITER → VALIDATOR → REWARD) in sequence on a shared blackboard
Produces scored, paste-ready Reddit replies targeting real conversations
Saves deployable copy to a local JSON queue for human review

The problem: I had no visibility into what the swarm was actually doing overnight. Logs are overwhelming. The JSON file is opaque. I couldn't quickly see which cycles scored highest, which agents were winning, or which outreach was ready to post.

Notion MCP fixed this. Now every completed swarm cycle automatically appears in a Notion database — score, MVP agent, outreach copy, target thread context, and posted status. Notion became the swarm's mission control dashboard.

How Notion MCP Is Used

I built nexus_notion_reporter.py — a side-car bridge script that:

Reads nexus_deployable_copy.json (the swarm's output file) every 60 seconds
Compares against a local state file to find new cycles not yet logged
Creates a Notion database row for each new cycle via the Notion API with:
- Cycle ID — unique swarm cycle identifier
- Score — REWARD agent's 0–1 quality score
- MVP Agent — which agent produced the best output
- Type — outreach type (REDDIT_REPLY, DM, etc.)
- Posted — checkbox, updated when human posts the copy
- Timestamp — exact cycle completion time
- Scout Context — what thread/signal was targeted
Embeds the full outreach copy as a block inside each Notion page

The Notion database schema is auto-created on first run — no manual setup needed.

Architecture

[nexus_swarm_loop.py]  ←— 8 AI agents running continuously
        ↓
[nexus_deployable_copy.json]  ←— scored outreach output queue
        ↓
[nexus_notion_reporter.py]  ←— side-car bridge (60s poll)
        ↓
[Notion: Swarm Cycle Log DB]  ←— mission control dashboard

The bridge is intentionally decoupled — it reads the swarm's output file only, never touching the running swarm process. Zero risk of disrupting the autonomous loop.

Why This Matters

Before Notion, reviewing swarm output meant: tailing multi-thousand-line log files, manually parsing JSON, no way to track which copy was deployed.

After Notion:

Every cycle is a database row — filterable, sortable, searchable
Sort by score to instantly find the best copy to post
Filter Posted = false → immediate deploy queue
Real-time: new cycle completes → Notion row appears within 60 seconds

Results
8 historical swarm cycles backfilled to Notion on first run
New cycles auto-log within 60 seconds of completion
Zero impact on running swarm (pure side-car architecture)
DB schema auto-provisioned — one command to start

python nexus_notion_reporter.py        # continuous mode
python nexus_notion_reporter.py --once # sync once and exit

Code

Code: nexus_notion_reporter.py (Gist)

Key file: nexus_notion_reporter.py

Built with: Python, Notion API (v2022-06-28), Ollama (local LLMs), Redis, SQLite
Swarm product: VeilPiercer — AI agent monitoring for local LLM developers

I built a 12-agent AI swarm that runs on my laptop 24/7 - launched today

fliptrigga13 — Tue, 24 Mar 2026 17:53:07 +0000

I've been building VeilPiercer in stealth for months and launched today on Product Hunt.

What it is

VeilPiercer runs 12 AI agents on your own hardware in a continuous loop - every 35 seconds they collaborate, score each other's outputs, and store lessons permanently.

No cloud. No OpenAI bill. Just your GPU doing the work.

The agents

SCOUT - finds real buyer signals from Reddit in real-time
COPYWRITER - writes outreach based on what SCOUT finds
COMMANDER - sets the strategy each cycle
REWARD - scores every agent's output (0.0 to 1.0)
SUPERVISOR - overrides bad decisions
METACOG - audits the swarm's own reasoning
...and 6 more

They pass context to each other via a Redis blackboard. The coordination graph enforces who reads who - no context soup.

The tech stack

Ollama (qwen2.5:14b, phi4:14b, llama3.1:8b) - all local
FAISS + SQLite - 3,900+ persistent memories, never wiped
Redis - shared blackboard + milestone state
asyncio - parallel tier execution
httpx - live Reddit signal fetching (no auth)

What it's doing right now

The swarm is running autonomously on my RTX 4060 laptop as I type this. It's completed 200+ cycles, tagged memories to active launch milestones, and is currently working on finding its first paying customer.

One-time $197. No subscription.

Product Hunt: https://www.producthunt.com/posts/veilpiercer

Site: https://veil-piercer.com

Would love feedback from the DEV community - especially on the agent coordination architecture.

NEXUS Ultra Notion: I wired my local AI swarm to Notion MCP and it updates live every 35 seconds

fliptrigga13 — Sun, 22 Mar 2026 20:51:13 +0000

The Problem I Solved

I was running 6 AI agents locally and had zero visibility into what they were doing. Every monitoring tool I tried added cloud costs I didn't want and still couldn't tell me why an agent drifted or looped silently.

So I built a self-monitoring AI swarm. The agents score each other. The best-performing agent each cycle gets logged. Lessons get written back to memory. After 72 generations it's meaningfully different from day one.

The problem: all of that intelligence was stuck in SQLite, Redis logs, and a terminal window.

What I Built with Notion MCP

I connected the NEXUS swarm to Notion using the Notion MCP API. Every 35 seconds, synced to the swarm's cycle interval, a Python connector reads the latest cycle data and pushes it into 3 live Notion databases automatically:

Cycle Reports — Every completed swarm cycle gets a row: cycle ID, score, MVP agent, task description, latency, status.

Agent Leaderboard — All 12 agents tracked in real time with individual scores and trend direction. The MVP agent gets flagged automatically.

Buyer Intelligence — SCOUT agent outputs, signals about potential buyers, flow directly into Notion where I can act on them without touching the terminal.

Setup

pip install requests

Add to .env:

NOTION_TOKEN=secret_your_token_here

Get your token at notion.so/profile/integrations. Create an integration, share a page with it, then:

python nexus_notion_sync.py

The connector auto-creates all 3 databases on first run. No manual Notion setup beyond the token.

How Notion MCP Is Used

The connector uses the Notion REST API to create databases programmatically with typed properties, push structured rows, and auto-configure itself from .env. Zero manual Notion setup beyond the token.

The entire data flow: 6 local LLM agents via Ollama run phi4:14b, qwen2.5:14b, mistral:7b. They complete a self-evaluation cycle. The REWARD agent scores them all. Redis blackboard captures the state. The Python connector reads it every 35 seconds and pushes it to Notion via MCP.

Results After First 20 Cycles

Cycle Reports: 6 rows and growing
Agent Leaderboard: 12 agents tracked per cycle with zero manual input
Buyer Intelligence: 8 real buyer signals already surfaced from SCOUT outputs
Zero cloud AI cost — all models run locally on RTX 4060

Code

https://github.com/fliptrigga13/nexus-notion-mcp

The product this swarm is helping sell: veil-piercer.com

I was paying $340/month to watch my AI agents. So I built my own monitoring layer that costs nothing.

fliptrigga13 — Sun, 22 Mar 2026 20:01:24 +0000

At some point I added up what I was actually spending to run my AI setup. Datadog, cloud logging, a couple monitoring SaaS tools. $340 a month. And none of it could tell me why my agent gave a confident wrong answer for six hours straight without a single alert.

The logs said nothing. The agent just kept going. By the time I caught it manually, it had already run hundreds of inference calls that were completely useless.

That's when I stopped paying for monitoring and just built my own.

What I built

It's a 6-agent swarm running fully local on my RTX 4060 via Ollama. No OpenAI. No Anthropic. No cloud anything.

The agents aren't just doing tasks - they monitor each other. Every cycle, each agent scores the others based on output quality, drift, and coherence. The results go into a reward model that adjusts weights for the next cycle. By generation 72 it's catching things I never would have noticed manually - drift in model output, agents silently looping, quality dropping before it becomes a problem.

The whole thing runs in 35-second intervals. It's currently sitting at:

2,478 persistent memories across sessions
Zero fail rate over the last 11 cycles
RAM at 54% with full parallel agent execution

Why I went offline

The $340/month thing wasn't even the main reason. I just got tired of not owning what I built. Every cloud tool means your prompts, your outputs, your agent behavior is hitting someone else's infrastructure. Running it local means nothing leaves my machine.

Also the zero per-token cost thing is real. Once the hardware is paid for, you're done. I've run 72+ evolution generations and it hasn't cost me a single API dollar.

The part that surprised me

The self-evolution actually works. I thought it would be a gimmick. But the swarm writes its own lessons back to memory after every cycle, and those memories get injected into the next cycle's context. It's not perfect, but it genuinely gets better. The SCOUT agent went from scoring 0.10 to 0.66 in six cycles just from better task alignment.

What it does in practice

Catches silent agent failures before they compound
Flags output drift across sessions
Builds market intelligence autonomously (buyer signals, competitor analysis, copy testing)
Runs 24/7 with no supervision required

If you want to try it

I packaged it up at veil-piercer.com. $197 one-time, source code included, runs on your hardware. No subscription. The whole point is you own it.

Happy to answer questions in the comments about the architecture if anyone's building something similar.