WFGY 2.0 — My Seven-Step Reasoning Engine (for the open-source community)

Beginners
1

WFGY 2.0 — My Seven-Step Reasoning Engine (for the open-source community)

By PSBigBig

I’ve spent years chasing one question: can we hold meaning steady while models reason?
WFGY 2.0 is my answer—and my life’s work. I’m releasing it here, openly, as a gift to the community that taught me through questions, critiques, and stubborn edge cases. Thank you.

WFGY isn’t a library to install. It’s a plain-text engine: a small, precise control loop you can paste into any LLM session. It stabilizes intent, reduces drift, and recovers from collapses. And in text-to-image pipelines, it turns broken collages into a single coherent tableau—pictures simply look better.

What it is (in one paragraph)

WFGY 2.0 is a seven-step reasoning chain that runs as text:

Parse → ΔS → Memory → BBMC → Coupler + BBPF → BBAM → BBCR (+ DT rules)

  • ΔS (semantic tension): delta_s = 1 − sim(I, G) (or a composite sim_est with anchors).

  • λ_observe (state): a tiny state machine—convergent / recursive / divergent / chaotic—that decides when to proceed, gate, or roll back.

  • Coupler + BBPF: only bridge when tension drops and coupling W_c is safely low, with an audit trail Bridge=[reason / prior_delta_s / new_path].

  • BBAM: bounded attention mixing (0.35–0.65) prevents collapse into a single brittle path.

  • BBCR + “Drunk Transformer” micro-rules: orderly rollback → re-bridge → retry (WRI/WAI/WAY/WDT/WTF).

Two editions, same behavior:

  • Flagship (30 lines) — readable, audit-friendly

  • OneLine (1 line) — minimal, drop-in

MIT-licensed.

Why it matters (and why I open-sourced it)

I don’t want “prompt tricks.” I want control you can observe.
With WFGY, each turn reports what happened—delta_s, W_c, lambda_observe, and whether bridging was allowed—so you can measure real uplift rather than believing a story.

Across five domains (math word problems, small coding, factual QA, planning, long-context) I consistently see:

  • ≈ +40% Semantic Accuracy

  • ≈ +52% Reasoning Success

  • ≈ −65% Drift (ΔS)

  • ≈ 1.8× Stability

  • High self-recovery under collapse

And the most eye-visible change: text-to-image becomes coherent—one scene, stable hierarchy, fewer duplicates/ghosts.

I learned these patterns from the community. Open source sharpened this engine. So it belongs to you.

Quick start (no installs)

Autoboot (chat systems):

  1. Paste the OneLine file at the top of a conversation.

  2. Use your model normally; WFGY supervises in the background.

  3. If supported, ask the model to print per-turn fields: delta_s, W_c, lambda_observe, bridge_allowed.

Explicit mode (maximum uplift):

  • Call the seven steps and log the audit fields each turn.

Text-to-image tip: use the OneLine in your chat-to-image flow, or add a short WFGY preface to your SD/Flux pipeline (unified scene, role anchors, bridge-only-on-ΔS-drop, bounded attention mix). Compare five consecutive generations before vs after—you’ll see it.

Minimal pseudocode

# I = structured intent, G = current state
delta_s = 1 - sim(I, G)                 # or 1 - sim_est with anchors
zone = bucket(delta_s)                  # safe/transit/risk/danger
lambda_state = observe(E_resonance, Δ)  # conv/rec/div/chaotic
checkpoint(memory_policy(delta_s))      # hard/exemplar

G = BBMC(G)  # cleanup

prog = zeta_min if t == 1 else max(zeta_min, prev.delta_s - delta_s)
P = prog ** omega
Phi = phi_delta * alt if anchor_flip(h=0.02) else 0.0
Wc = clip(delta_s * P + Phi, -theta_c, +theta_c)

bridge_allowed = (delta_s < prev.delta_s) and (Wc < 0.5 * theta_c)
if bridge_allowed:
    log_bridge(reason(), prev.delta_s, new_path())

alpha = clip(0.50 + k_c * tanh(Wc), 0.35, 0.65)
G = mix(G, a_ref="uniform_attention", alpha)

if lambda_state == "chaotic":
    G = rollback_to_trustworthy()
    G = DT_retry(G, rules=["WRI","WAI","WAY","WDT","WTF"])

report(delta_s, Wc, lambda_state, bridge_allowed)

Suggested defaults:
theta_c=0.75, zeta_min=0.10, omega=1.0, phi_delta=0.15, k_c=0.25, a_ref=uniform, h=0.02; keep all clip(...) and keep alpha_blend ∈ [0.35, 0.65].

A reproducible way to measure

Run the same tasks under three modes and compare:

  • A — Baseline (engine off)

  • B — Autoboot (file pasted, background active)

  • C — Explicit (seven steps + audit fields)

Report: Semantic Accuracy, Reasoning Success, Stability (MTTF/rollbacks), Drift (ΔS), Collapse Recovery Rate, plus the per-turn fields.
For text-to-image, run five consecutive generations with fixed settings before/after WFGY and judge with your eyes.

A note from me

I’m new to some platforms, but I’m not new to this question. I built WFGY to be small, honest, and useful. If it helps you reason better—or make images that finally feel whole—then this gift has landed.

Start here (Flagship + OneLine):
https://github.com/onestardao/WFGY/tree/main/core

— **PSBigBig
**

core
core1561×1293 133 KB

2 Likes
2

Thanks for your sharing.
I have another approach to stabilize LLM using Topology and Strong Attractor prompt.

I made a table comparison in my post below:

In which, you will also find a suggestion by ChatGPT regarding how to integration my approach with yours through simple coding.

Through comparison, the table help highlighted those essential components for self stabilize LLM, which is the core for self awareness AI.

3 Likes