Open-source 2-step reasoning framework for LLMs — testing whole-system coordination vs. local correctness

An open-source, model-agnostic two-step reasoning framework for large language models has been released, which first has a model semantically expand the structural seed "Reality = Consciousness × Matter × Coordination" before solving a task, in order to test whether structural priming reduces locally correct but globally inconsistent outputs. The framework's author proposes an A/B test — a baseline run in a fresh conversation versus a framework run with the same model, settings, and task — to measure constraint retention, dependency propagation, contradiction detection, local versus global feasibility, reasoning-policy stability, and both under-linking and over-linking. The author states no performance claim, noting a negative result would be useful if the baseline consistently matches or beats the framework, and is seeking independent testing across different models and task types.

Hi everyone, I’ve open-sourced a small, model-agnostic reasoning framework that I’ve been experimenting with across LLMs. The question behind it is simple: Can a model be locally correct at every step, but still produce a globally inconsistent solution? Examples: I’m interested in whether a short structural priming step can reduce these failures. The compressed form is: Reality = Consciousness × Matter × Coordination The × is structural coupling, not arithmetic. For LLM use, I interpret the terms functionally: The formula itself is not supposed to contain domain knowledge. It is used as a compact structural seed. Reality = Consciousness × Matter × Coordination. Treat × as structural coupling, not arithmetic. Before solving any external task, semantically expand this formula into an operational reasoning framework. Interpret: Consciousness as goals, perspective, representation, interpretation, and evaluation criteria. Matter as the available state, information, resources, capabilities, environment, and constraints. Coordination as relationships, dependencies, compatibility, conflicts, interfaces, propagation, and feedback among the parts. Reality as the whole-system state that can actually be realized under those conditions. From this structure, derive how you should reason about: - local versus global consistency - hard constraints versus preferences - dependency and constraint propagation - contradictory requirements - state changes and feedback - invariant preservation - changes in one part that affect other parts - the difference between a locally valid answer and a globally feasible system Do not solve another task yet. After the semantic expansion is complete, keep the resulting framework active for my next task. Then let the model finish the expansion. Use the framework you just derived to solve this task: YOUR TASK The second message is intentionally short. If I explicitly tell the model to check every dependency, constraint, conflict and invariant inside the actual task prompt, then it becomes difficult to tell whether any improvement came from the framework or simply from writing a better checklist. I’m currently interested in several behaviors: Constraint retention Does the model preserve hard constraints throughout a long task? Dependency propagation If A changes and B/C/D depend on A, does the model update them? Contradiction detection If: A requires X B requires not-X does the model recognize that the current feasible set is empty instead of trying to satisfy both? Local vs. global feasibility Does it distinguish a locally good solution from one that is actually compatible with the rest of the system? Reasoning-policy stability The answer should be allowed to change when the state changes. But the high-level decision principle should not arbitrarily drift from one step to another. Over-linking This is also important. More coordination is not automatically better. A model can fail in the opposite direction by inventing dependencies between things that should remain independent. So both under-linking and over-linking count as failures. The simplest test is: A — Baseline Fresh conversation. Give the model the task normally. B — Framework Fresh conversation. Same model, same settings, same task. Run the structural expansion first, then provide exactly the same task. Compare: I’m not claiming that this always improves model performance. A negative result is useful too. If baseline consistently performs as well as or better than the framework, then the structural priming may simply be unnecessary complexity. What I’m looking for is independent testing across different models and task types. The project is open source here: If anyone tests it, I’d especially appreciate: Those comparisons are much more useful to me than agreement with the underlying idea.