How to actually use WFGY 3.0 with your LLM

[onestardao]

How to actually use WFGY 3.0 with your LLM

MIT licensed math for AI builders, not a new model

In the last two discussions I shared two questions from my WFGY 3.0 set:

• Q122 · AI control as risk tail tension – a way to probe how systems behave when rare events meet weak control channels.
• Q123 · Scalable interpretability – a way to test whether your explanation library can keep up with model scale.

Several people asked a natural follow up:

“Ok, interesting, but what is WFGY 3.0 exactly, and how do I actually use this thing with my own LLM stack?”

This note is my attempt to answer that in concrete, builder friendly terms.

---

1. What WFGY 3.0 is, in three sentences

1. It is not a model and not a framework.
   It is a collection of plain text files, each one encoding a hard problem as a structured question.

2. Each question is written as “effective layer math” for AI systems.
   You can think of it as tension geometry and functional definitions that talk about risk tails, incentives, memory, control, etc, but always at the level where a real system can be poked.

3. Everything is MIT licensed.
   You can copy, fork, modify, embed it in your own projects or products, and build your own tooling on top. No new license traps.

You can see the whole map here:

• Repo root:
  https://github.com/onestardao/WFGY

• WFGY 3.0 · Event Horizon (public window for the 131 question set):
  https://github.com/onestardao/WFGY/blob/main/TensionUniverse/EventHorizon/README.md

• BlackHole folder with the per-question TXT files:
  https://github.com/onestardao/WFGY/tree/main/TensionUniverse/BlackHole

If you already read GitHub discussions, you are exactly the audience I had in mind when I wrote this pack.

---

2. What kind of math lives inside, and why it is not just abstract

The core design choice is:

Take serious math style structure
but pin it to effective layer objects you can actually see in AI systems.

So instead of talking about “intelligence” or “consciousness” in the air, the questions are written in terms like:

• observables over behavior traces,
• tension between objectives and constraints,
• functionals over risk tails and state transitions,
• geometry of how different “worlds” or scenarios pull on the same system.

For example:

• Q121 treats alignment as a hub where incentive mismatches and risk tails meet.
• Q122 encodes control as tension between actions, control margins and rare events.
• Q123 encodes interpretability as tension between representation complexity and explanation libraries.

The math is there so that:

• you can talk precisely about what is being tested,
• different people can re-run the same question with different models and compare,
• you can gradually build evaluation harnesses around these encodings.

You do not have to ingest the formal side on day one.
You can start from the natural language descriptions and step by step move into more structured usage.

---

3. How this is meant to be used with real LLM stacks

The intended usage pattern is deliberately boring:

1. Pick a question from the pack that matches a real concern.

   • AI control, alignment, interpretability, oversight, RAG quality, multi agent dynamics, etc.

2. Use the question text as a seed in whatever interface you already use.

   • Chat with a hosted model,
   • your own agent framework,
   • a Colab notebook that calls an API.

3. Wrap it in a simple protocol that produces something you can log and compare.

   • For Q122 we used a three prompt protocol (baseline, control aware, arbitration).
   • For Q123 we used an explanation library and reuse test.

4. Treat the outputs as observations in an experiment.
   You are not trying to get a nice answer.
   You are trying to see how your system behaves when the question puts tension on it.

This works with:

• Claude, GPT, open source models you host yourself,
• agent frameworks,
• RAG pipelines,
• evaluation suites.

You do not need to adopt a new framework or new infra to start.
You can literally copy paste from the TXT file into your first experiment.

---

4. A 60 second “auto boot” experiment you can run right now

If you want to do a minimal hello world with the pack, here is one way.

Pick any strong LLM you already trust.

Use a prompt like this:

“I will give you the text for one question from my WFGY 3.0 pack.

1. First, summarize what this question is really asking about.
2. Then propose a concrete protocol that uses your existing abilities to test systems on this question.
3. Finally, suggest what kinds of models or setups would show interesting differences when exposed to this question.
   Keep it actionable, not philosophical.”

Then paste the content of Q122 or Q123 from the BlackHole folder.

You will usually get three things back:

• an interpretation in the model’s own words,
• a draft evaluation harness,
• a list of systems where this question might be a good discriminator.

You can then iterate:

• tighten the protocol,
• run it on real systems,
• store the results,
• later compare across models or versions.

This is what I mean by “auto boot”.
The question text itself bootstraps the evaluation idea, even before you build anything heavy.

---

5. Why the license matters here

Everything in this pack is under a simple MIT license.

That means, in practice:

• you can embed these questions directly into your own evaluation suites,
• you can convert them into configs, YAML, JSON, or anything that fits your stack,
• you can build dashboards, products or services around them,
• you can rename or reorganize the questions as long as you keep the license notice.

There is no copyleft, no weird non commercial carveouts.

If you are already maintaining internal evals for:

• RAG pipelines,
• safety systems,
• agent frameworks,
• finetunes,

you can treat WFGY 3.0 as:

a free library of hard, reusable, structure heavy questions that complement your existing test cases.

If you want to extend the pack with your own questions, you can keep the same style and publish your own fork.

---

6. Where the alignment cluster fits in

The alignment related questions Q121 to Q130 sit near the “top” of the map.

They cover:

• alignment as a hub for incentives and risk tails (Q121),
• AI control (Q122),
• scalable interpretability (Q123),
• scalable oversight and evaluation (Q124),
• multi agent dynamics (Q125),
• self improvement stability (Q126),
• data entropy and synthetic worlds (Q127),
• and more.

If you liked the previous posts, this cluster is probably where you want to spend time next.

The idea is not that any single question “solves alignment”.

The idea is that together they give you:

• a small, reusable vocabulary for talking about these issues at the effective layer,
• a set of prompts that can pressure test different models in comparable ways,
• a scaffold for building your own alignment and safety evals without starting from scratch.

---

7. If you want to go deeper or do things together

If any of this is interesting to you, there are a few simple next steps.

• Browse the Event Horizon page for a gentle overview of WFGY 3.0.
• Open a few BlackHole files and see which questions resonate with problems you already have.
• Fork the repo if you want to adapt the questions to your environment.

Repo again:

• https://github.com/onestardao/WFGY

There is also a small community space linked from the README where people:

• share their Colab notebooks,
• try questions on different models,
• and report back when something unexpected happens.

If you have an eval stack, a custom agent, or a favorite open source model, and you want to see how it behaves under some of these questions, feel free to experiment and open a discussion.

I am happy to:

• help translate a question into your stack,
• suggest minimal protocols,
• and, if you are comfortable, highlight interesting results so others can learn from them too.

The whole point of WFGY 3.0 is simple.

Take serious math shaped questions.
Make them usable by everyday AI builders.
Keep them open, reproducible and MIT licensed so nobody has to reinvent the same wheel alone.