One-size reasoning · the same strategy for a 3-step task and a 30-step chain. Frozen at deploy?
Optimize your agents runtime with reasoning procedures that compound in the context.
Suppress failures modes, improve performance when task complexity raises.
Pattern feeding cognitive operations engineered for long horizon autonomous systems.
Give dynamic & adaptive reasoning to your ai automations.
@adamcreates_ Ehy Adam, have a loot at https://t.co/zNln977Rin , we are building th reliability layer by improving reasoning during inference, better decisions, less failures. Ping me if u are interested to have a chat
Thinking about thinking
A multi-step run wiith self-inspect and superposition in the loop.
checking the model reaction against autonomous self-doubt and and self location in a decisional axis.
A small experiment pushing sonnet 4.6 into writing about self-examination of its own thought process.
notes :
What separated Sonnet's run from ordinary generation is that it kept catching its own earlier claims as wrong and changing direction, and those redirects line up with the tool calls. At turn 11 it overturned its "partial knowledge" thesis with a counterexample and replaced it with a warm versus cool distinction that carried the next ten turns; at turn 34 it caught itself treating self-examination as purely epistemic, tested that against Zen sitting and an athlete in flow, and split it into model-building versus mode-being, its strongest stretch. Along the way it derived a structural claim about opacity and then predicted its felt consequence (turns 23 to 24), swapped an undecidable test for a workable one (turns 29 to 30: since good and bad faith feel identical from inside, judge by revisability instead), bounded its own results, and ended at turn 38 having inverted the intuition it started with at turn 1. The three tool calls land on exactly those turning points. That is the whole claim: the tools did not make the model smarter, they marked the real walls, and a capable model turned each one into a direction it then built on.
Metacognition happens when the agent reaches for the tool not when forced. https://t.co/xceuoE2BUv
https://t.co/OHFWzVR0IU is the reppresentative company of the movement of the reasoning tools for agentic AI
More if you want to poke at it:
→ The whole engine in one zero-dependency Python file: https://t.co/K22JXI1uHR
→ Try it live, no key: curl -sX POST https://t.co/K5tkEtGapt -H 'content-type: application/json' -d '{"task":"...","description":"...","wants":"..."}'
→ The reproducible eval + the raw transcripts (run it on your own agent): https://t.co/HO8mYAClwi
→ The architecture and the decision record (why the connective is —?— where physics writes +): https://t.co/KTbO4Hk8Ta
→ Sibling tool, same idea pointed at self-questioning: https://t.co/pFfJCJMbI9
Premature Collapse: the measurement problem in AI agents
Superposition is a tool that catches an agent the moment it commits to one reading of an ambiguous task. The agent states three views of what it is doing, and gets back a two-pole map: an axis with both readings held open and a question that forces it to locate which side it is on. It picks on purpose instead of by reflex.
The failure it targets is everywhere. Most tasks you give an agent are ambiguous. "Fix the timezone bug" is three jobs wearing one sentence: make the failing test pass, stop users seeing the wrong time, or fix the offset logic underneath. A decent engineer holds all three and picks deliberately. Agents grab the loudest one in the first 50 tokens and sprint off, building the wrong thing flawlessly. I call it premature collapse.
The name is borrowed from quantum mechanics, and it is tighter than it has any right to be. A quantum state is a real blend of possibilities, |ψ⟩ = α|A⟩ + β|B⟩, and it stays a blend until you measure it. Two things get glossed over. The blend is real, not you being unsure which. And you choose the basis you measure in, which decides what you can even see. Premature collapse is the agent measuring too early, in whatever direction felt loudest, before it ever held the options or picked an axis.
Stating the three views is the part that does the work. The agent goes from holding one frame to holding several of its own at once. I call that frame multiplication. Then the map gives it the axis to hold them against:
| the fix as stated ⟩ —?— | the intent behind the report ⟩
The map is the basis. The question under it ("which am I serving, and what makes the other one a real mistake here?") is the measurement. The agent answers it and collapses the state with its eyes open. The connective sits where physics writes a +, but it is a question mark on purpose: both sides are held, and how they relate is the open part.
Now the bit people don't believe at first. No model touches this. The map is pulled from an open CSV, identical bytes every time, same input same map forever. No embeddings, no second model, no prompt to babysit. It is not advice. It sets the agent's own framing down next to it, at the second it would otherwise snap shut.
We A/B tested it. Same model, same scenario, one run with the tool, one without. The result was not what I expected. On a strong model it did not produce a better technical answer; a good model already gets the engineering right. What it did, in every run we tried, was catch the fork the other run ran straight past: the second-order consequence. One run shipped a clean, correct plan that strolled into a stakeholder landmine it never noticed. The run holding the axis saw it coming and planned around it. Same model, same prompt. The only difference was whether it held the options before choosing.
So I am not going to tell you it makes agents smarter. It does not. It makes them see the choice they were about to make blind. One cheap call, and the agent audits its own framing.
by @ejentum reasoning harness to the AI community of experimenters and developers and enterpreneurs.
Keyless, free, open source. REST, MCP, and a single Python file with zero dependencies. https://t.co/mH4uaeJdGI
@Tancrededib reasoning tools for ai agents, already available in 15 frameworks, MCP & http that improves agentic performance during inference, proven. https://t.co/zNln977Rin i am the technical one u are looking for
This is how i boost reasoning in my daily ai workspace by using @ejentum tools
screenshot from my claude code instance while using reasoning mode on.
start up session with fresh contexxt, 3 reasoning strategies in and a goal.
Everybody treating reasoning as fascinating concept, that is to be decoupled from ai researchers and ai engineers and installed in the weights of the model.
False, today we have the tools and the models to harvest the max power staying idle and waiting the harness like claude code, codex or cursor doing its work.
Feeding dynamically abstract reasoning abilities that match to the task gives a way to the powerful agent to perform the analogy, instead of spending the generation output on reasoning and acting.
You are giving to your systems a ladder ready to climb and outperform the version of itself that did not have ejentum on its available tools.
Both verified live (REST returns a metathought, npm at 0.1.0). The full set:
Endpoints (keyless, no API key):
REST: https://t.co/Qj35aWczpS (POST {"thought":"..."}, ~120/min per IP)
MCP over HTTP: https://t.co/axvHnBeCpt (Streamable HTTP, ~60/min per IP)
Install / run:
npm (stdio MCP): npx -y self-inspect-mcp
Claude Code: claude mcp add --transport http self-inspect https://t.co/axvHnBeCpt
Links:
GitHub repo: https://t.co/lvFHUf2t0V
Evals (data + reproduction): https://t.co/aNdmcCJ8a8
npm package: https://t.co/l81UT4MVp2
What if, mid-task the agent could get a self-check bump that surfaces the silent assumptions of your itself. Got legibiliity of the silent forks and decision routing in the outputs. thesis? readability and better coop agent to agent and human to agent.
I ran the evals on self-Inspect-mcp of @ejentum , and the result is worth sharing because it was not the one I went looking for.
Two coding agents built the same usage-billing module over 30 turns. One consulted Self-Inspect once per turn; the other didn't. Same model (Claude Sonnet 4.6), same conversation, same prompt. The only variable was the question.
The agent with it surfaced 3.5x more assumptions and edge cases (14 of 30 turns vs 4 for the baseline), and it flagged a real billing bug the plain agent shipped right past: a snapshot-averaging error that would have mis-charged customers. At one point it was asked "What is assumed?" and answered, "I've been assuming persistence lives outside the module," surfacing a decision it had never said out loud.
Here is the honest finding, and the reason I'm posting data instead of a demo: on a fully-specified task it did not make the model more correct. A capable model already self-checks there. What moved was legibility, the silent forks came into the open where a human can catch them. A thoroughness and transparency amplifier, not a correctness booster. The full data and a one-command reproduction are public.
https://t.co/3dZuWIiiTt
@celio1878 If you fix the data you fit in the vdb, you are solving 80%. Get some strong model to fix and improve the datasets you are feeding in, and production gets a reliable rag
@anchorstack_dev building reasoning tools for AI agents, inference time reasoning structures injection, fail less & reason better
https://t.co/zNln977Rin connected
@ZachZelle Ehy Z , I recently launched a set of agentic tools that improve reasoning performance in coding and complex tasks. Would u be interested to look at it?
@JoinFireLaunch I am working on https://t.co/zNln977Rin http & mcp endpoint tools that improve reasoning performance for long running agents specifically for code generation and complex thinking tasks. https://t.co/v0WloPKHQt & open source keyless endpoint
https://t.co/QzQ2O5EUJS .
Cheers 🍻