AHA Quickstart: Your First FORGE Session#

Created: 2026m03d27

This walkthrough uses an imaginary Model X — a model of how collaborative innovation scales — to demonstrate every step of a FORGE session. Follow along to learn the commands, the LLog protocol, and the phase cycle.

Before You Start#

Prerequisites:

  1. WisdomBase sheets exist in forge/wb/. If not, run the pre-forge compiler prompts first (see FORGE — Formally Organized Research Growing Extensibly).

  2. Start a clean session — either a brand-new Claude session or one that has been compacted (/compact). FORGE prompts are large and need a fresh context window to work properly. Do not paste a forge prompt into a session that already has substantial conversation history.

  3. Choose your forge prompt and paste it into the session:

    FORGE — 200K Token Window

    Start here. Fits a standard 200K context window. Loads the axiom system, symbol tables, and existing models but NOT the full HELL landscape. ~84K working space with WB sheets, ~104K without. Good for quick sketches, exploring ideas, and early formalization. Use this unless you know you need the full adversarial arsenal.

    FORGE — 1M Token Window

    Deep work. Requires a 1M context window. Loads everything the 200K variant loads PLUS all 66 HELL findings (33 con + 33 pro), the full BEST naming architecture, and the SISYF skill spec. ~722K working space. Use this when stress-testing claims against known attacks (Iron Maiden tests IX and X require the full HELL landscape).

    Tip

    How to copy the prompt: Click a link above to open the prompt page. Scroll to the The Prompt section. Select everything inside the code block (starting from /effort max down to the last line). Paste it as your first message in the clean session.

    Future improvement: Adding sphinx-copybutton to the build would give every code block a one-click copy button, eliminating selection errors.

Step 1: IGNITE — Light the Forge#

What you type:

FORGE:IGNITE
scope: Collaborative innovation scaling
question: Under what conditions does collaborative innovation
          outperform competitive innovation in the long run?
zone: JUB model — extends th8 (Binary Attractors) with a third
      attractor for collaborative equilibria
wb: dynamical-systems, ergodic-theory, mechanism-design

What happens:

The agent creates:

forge/llog/sa1_2026m03d27/meta.rst    (session metadata)
forge/llog/sa1_2026m03d27/llog.rst   (empty LLog, first entry added)

The agent writes the IGNITE entry to the LLog, recording your scope, question, and zone verbatim. It confirms the WB sheets are loaded and summarizes what they provide for your question.

What you should check:

  • Does the meta.rst accurately reflect your scope and question?

  • Are the right WB sheets loaded?

  • Does the agent’s initial orientation match your intent?

Step 2: HEAT — Explore the Problem Space#

What you type:

FORGE:HEAT

I think there might be a third attractor in the th8 system —
not just "river of life" and "BABL" but a collaborative
equilibrium where agents coordinate on shared innovation.
My intuition says it only appears when the state space includes
a "trust" dimension. What does the dynamical systems WB sheet
say about adding dimensions to an attractor system?

What happens:

The agent appends a HEAT phase header to the LLog, then responds to your question. Its response is logged:

  • Your prompt goes in .. container:: verbatim-prompt (full text)

  • The response is summarized with key findings highlighted

  • Any references to WB sheets are noted

The HEAT phase is for exploration. Ask open questions. Float intuitions. Let the agent connect your ideas to formal frameworks. Nothing is committed yet. Multiple prompts within HEAT are fine — each one gets its own LLog entry.

Typical HEAT prompts:

  • “What does [WB sheet] say about [my idea]?”

  • “Is there precedent for [this kind of structure] in [formal area]?”

  • “What would go wrong if I assumed [X]?”

  • “How does this connect to [existing axiom/theorem]?”

Step 3: STRIKE — Formalize#

What you type:

FORGE:STRIKE

Based on the HEAT exploration, I want to formalize:
1. A three-variable state space (I, R, T) where T = trust index
2. An evolution equation that couples T to innovation rate R
3. A claim that for T > T*, a third attractor appears
   (pitchfork bifurcation from the river-of-life attractor)

What happens:

The agent appends a STRIKE phase header with a HEAT summary (what was explored, what ideas emerged, what was promising). Then it helps you formalize:

  • Writes precise definitions

  • States axioms and conjectures in formal notation

  • Identifies what follows from existing axioms vs. what needs new ones

  • Flags potential conflicts with existing theorems

Every formal statement the agent produces is logged verbatim in the LLog (Rule 3). Informal discussion is summarized, but anything with symbols, quantifiers, or formal structure goes in full.

Typical STRIKE prompts:

  • “Define [concept] formally using the notation from [WB sheet]”

  • “State [claim] as a conjecture with explicit assumptions”

  • “What axioms do I need to derive [theorem]?”

  • “Write the evolution equations for [system]”

Step 4: TEMPER — Stress-Test#

What you type:

FORGE:TEMPER

The formalization from STRIKE gives us a three-attractor system.
Run the Iron Maiden tests on the third-attractor claim.
Specifically: structural stability, basin boundary analysis,
and sensitivity to the trust coupling constant.

What happens:

The agent appends a TEMPER phase header with a STRIKE summary (what was formalized, what was left informal, any gaps). Then it shifts to adversarial mode:

  • Applies Iron Maiden tests to formal claims

  • Probes edge cases and boundary conditions

  • Checks for conflicts with existing axioms and theorems

  • Assigns preliminary StayC verdicts to each claim

StayC verdicts in TEMPER are the agent’s independent assessment (dv_ track). Your assessment (iv_ track) is recorded when you agree, disagree, or reserve judgment.

Typical TEMPER prompts:

  • “Run Iron Maiden test [N] on [claim]”

  • “What happens to [claim] if [assumption] fails?”

  • “Find a strongest objection to [formal statement]”

  • “Is this structurally stable under [perturbation]?”

Step 5: QUENCH — Consolidate#

What you type:

FORGE:QUENCH

What happens:

The agent appends a QUENCH phase header with a TEMPER summary (what was tested, what held, what breached, what was undetermined). Then it produces a round summary:

  • Claims and their StayC verdicts (both iv_ and dv_)

  • Open questions (what could not be resolved this round)

  • Proposed HELL entries (attacks and defenses worth preserving)

  • Dependencies (what this work needs from other parts of the system)

Decision Point: ROUND or BANK?#

After QUENCH, you decide:

Start another round (the TEMPER revealed issues to fix):

FORGE:ROUND

The third-attractor claim failed structural stability at the
basin boundary. I want to try a modified coupling that uses
a sigmoid rather than linear trust function.

This increments the round counter and returns to HEAT. The LLog records the round boundary with a summary of why another round is needed.

End the session (the work is at a natural stopping point):

FORGE:BANK

I'm satisfied with the formalization up to the structural
stability issue. The sigmoid coupling is a hypothesis for next
session. Please bank with proposed HELL entries for the
third-attractor conjecture.

Step 6: BANK — End the Session#

What happens at BANK:

The agent writes a comprehensive session summary to the LLog:

  1. Session overview — scope, question, rounds completed

  2. All findings — what was discovered, formalized, tested

  3. All StayC verdicts — every claim with both iv_ and dv_

  4. Proposed HELL entries — draft con/pro entries for HELL integration

  5. Open questions — unresolved issues for future sessions

  6. Next steps — specific suggestions for the next session

  7. Meta update — status changed from ACTIVE to BANKED

The agent also updates llog/index.rst with a one-line session summary.

After BANK, the session is complete. The LLog is the permanent record. Anyone can read it to follow the entire progression of ideas.

Recovery: FORGE:EMBER#

If your session was interrupted (context exhaustion, timeout, crash):

  1. Start a new Claude session

  2. Load the forge prompt

  3. Type:

FORGE:EMBER sa1

The agent reads the existing LLog and meta from llog/sa1_2026m03d27/, summarizes where things left off, and proposes a resumption point. You confirm or redirect, then continue with normal phase commands.

The LLog must exist for recovery to work. This is why the protocol requires logging every response (Rule 1). An unlogged session is unrecoverable.

Quick Reference Card#

┌─────────────────────────────────────────────────┐
│  FORGE:IGNITE  scope="..." question="..."       │
│       ↓                                         │
│  FORGE:HEAT    (explore, gather, connect)       │
│       ↓                                         │
│  FORGE:STRIKE  (formalize, define, state)       │
│       ↓                                         │
│  FORGE:TEMPER  (stress-test, adversarial)       │
│       ↓                                         │
│  FORGE:QUENCH  (consolidate, verdict, record)   │
│       ↓                                         │
│  ┌── FORGE:ROUND ──→ back to HEAT               │
│  │   (if more work needed)                      │
│  │                                              │
│  └── FORGE:BANK                                 │
│      (if done — writes session summary)         │
│                                                 │
│  FORGE:EMBER sa1                                │
│      (recover interrupted session)              │
└─────────────────────────────────────────────────┘

Rules (the short version):

  1. Every response logs to the LLog file.

  2. Prompts are recorded verbatim — always.

  3. Formal content is never summarized — always verbatim.

  4. Phase transitions include outgoing-phase summaries.

  5. BANK before leaving.

  6. EMBER reads everything before writing anything.

  7. Append-only, forever.