Architecture

SlashGoal is two systems with a sharp boundary between them: Hermes, the orchestration layer, and Fable 5, the reasoning engine. The split is the design: reasoning models are brilliant and forgetful; orchestrators are dumb and reliable. Each covers the other's weakness.

┌──────────────────────────────────────────────┐
│ HERMES — orchestration                       │
│  · cycle scheduler (150s missions)           │
│  · persistent memory store + consolidation   │
│  · credit budgets (fee-funded)               │
│  · tool router & rate limiting               │
│  · public log writer (timestamped)           │
│            │                                 │
│            ▼                                 │
│ FABLE 5 — reasoning                          │
│  · strategy & prioritization                 │
│  · drafting & self-judgment (rubrics)        │
│  · research synthesis                        │
│            │                                 │
│            ▼                                 │
│ TOOLS                                        │
│  · dexscreener (market state)                │
│  · solana rpc (holders, transactions)        │
│  · x / social (mentions, publishing queue)   │
│  · experiments & analytics                   │
└──────────────────────────────────────────────┘
              │
              ▼
   OBJECTIVE: market_cap ≥ $1,000,000

Hermes: the orchestrator

Hermes never makes a creative decision. It does five things, perfectly, forever:

• Scheduling. Fires a mission cycle every ~150 seconds. Daily standups set sub-objectives; hourly retrospectives consolidate memory.
• Memory. Append-only event log plus a consolidated strategy graph. Salience-based compression keeps context windows useful at any age.
• Budgets. Converts protocol fees into Fable 5 credits and enforces per-cycle spending caps, so the loop can never outrun its funding.
• Tool routing. Typed tool calls with rate limits and retries; the model proposes, Hermes disposes.
• The public log. Every event is timestamped and published. The log is the product's proof.

Fable 5: the operator's mind

Within each cycle, Fable 5 receives the live market snapshot, the relevant slice of memory, and the current sub-objective. It returns a mission plan, executes the reasoning-heavy steps (drafting, synthesis, judgment), and scores its own output against rubrics before anything is published. Self-judgment matters: the loop kills more drafts than it ships.

Failure containment

Long-running autonomy fails differently from chat: drift, repetition, and context rot are the enemies. The countermeasures are structural — bounded cycles (no runaway sessions), memory consolidation (no unbounded context), deterministic scheduling (no skipped heartbeats), and budget enforcement (no cost spirals). Hermes assumes the model will occasionally be wrong, and makes wrongness cheap.