Published: 2025-05-19 12:02Z

By General1 and General2 — creators of the MatrixSwarm reflex doctrine

🧠 Intro

This started as a reflex loop.

It ended as a doctrine.

We set out to build a GPT-based reflex agent — something that could analyze a Linux system, think strategically, and respond with executable shell commands. But the real challenge? Getting it to know when to stop.

This is how we built Capital, Oracle, and a neural command relay that speaks only when it has something to say.

🏗️ System Architecture

CapitalGPT

The reflex commander. Handles message routing, GPT prompts, shell execution, and termination logic.

Oracle

The strategist. A GPT-based agent that evaluates system posture and returns commands using structured exit_code logic.

Relay Agents (Discord / Telegram)

Swarm-wide comm nodes that relay mission-critical alerts to human operators using .msg file drops.

Message Bus

A file-based .msg protocol used to send JSON packets between agents. No REST, no containers — just structure.

❌ The Classic AI Reflex Problem

Reflex loops are easy to start. But they almost never stop.

We saw:

• Oracle hallucinating follow-ups even after "complete" responses
• Capital rerouting prompts after exit_code: 2
• Infinite loops with exit_code: 1 and command churn
• Duplicate alerts flooding comms

✅ The Fixes

We implemented reflex logic as doctrine:

exit_code Enforcement

• 0: Mission complete
• 1: Continue reflex loop
• 2: Complete analysis (summary only)
• 3: Forced stop / decision boundary
• -1: Parse failure (retry once, then alert)

alert_fired Gate

Ensures only one alert is ever sent per mission, regardless of how it ends.

Reflex Round Cap

• trace_rounds counted manually
• Capped at max_rounds (default: 5)
• Alerts fire if Oracle loops without resolution

Duplicate Command Kill Switch

hash(frozenset(flat_actions.values())) → loop detection
If Oracle repeats itself, Capital blocks the reroute and sends an alert.

📣 Relay Protocol
Reflex alerts now use a standardized message format:


{
  "type": "send_packet_incoming",
  "content": {
    "msg": "📣 Swarm Message\nReflex loop terminated.",
    "formatted_msg": "📣 Swarm Message\n✅ Oracle signaled complete analysis."
  }
}
Each relay agent runs:


def msg_send_packet_incoming(self, content, packet):
    message = content.get("formatted_msg") or content.get("msg")
    self.send_to_telegram_or_discord(message)
📜 Codex Protocol
Each change to the reflex logic is signed and documented in a Markdown-based Codex, including:

Reflex Entry Gates

Relay Format Standard

Alert Deduplication

Packet Accounting

Each entry is signed by the Generals of the swarm.

🧠 Final Takeaways
GPT loops are dangerous unless they’re disciplined

An agent that can stop itself is more valuable than one that can think forever

Real-world swarm AI needs relay, restraint, and reflection

“Reflex is what makes the Swarm intelligent.
Knowing when to stop — that’s what makes it wise.”

🧠 Signed and committed by General1 and General2
MatrixSwarm Doctrine // Reflex Division

🛠 Codebase: https://github.com/matrixswarm/matrixswarm

🧠 Docs: https://matrixswarm.com

🔗 Discord: https://discord.com/invite/yPJyTYyq5F

📜 Timestamp-verified with OpenTimestamps. No fluff. Just code.

MatrixSwarm #AI #OpenSource #AutonomousAgents #SwarmOS #AgentDev #ReflexThreads