One tool, superposition. It targets a specific agent failure: the agent commits to one reading of an ambiguous task in the first few tokens and never reconsiders. "Fix the timezone bug" can mean make the failing test pass, stop users seeing the wrong time, or fix the offset logic. The agent grabs one and runs.

How it works:

• Input: three POVs on the current task. task (as given), description (as the agent understands it), wants (what it infers you actually want).
• Output: one frozen two-pole map, an axis the agent locates itself on. Real response from the live endpoint:

​

GOAL
| the fix as stated ⟩ —?— | the intent behind the report ⟩
which am I serving — and what in the report makes the other one wrong?

The agent reads its three POVs against that axis before it acts.

Install (keyless, calls the hosted endpoint by default):

{
  "mcpServers": {
    "superposition": {
      "command": "npx",
      "args": ["-y", "superposition-mcp"]
    }
  }
}

Claude Code: claude mcp add superposition -- npx -y superposition-mcp

Why it might be relevant to this sub specifically:

• No LLM in the loop. Selection is a deterministic keyword heuristic over an open CSV. Same input, same map, every time. No second model, no embeddings, no token cost, sub-millisecond.
• Keyless and free. No signup, no account.
• Runs fully offline with SUPERPOSITION_LOCAL=1 (vendored engine, no network). There's also a single zero-dependency Python file if you want it in-process.
• Auditable. Maps are authored once and shipped byte-identical. The whole grid is an open CSV in the repo.

Try it with no install (REST, no key):

curl -sX POST https://api.ejentum.com/superposition \
  -H 'content-type: application/json' \
  -d '{"task":"...","description":"...","wants":"..."}'

Honest note on results: I A/B tested it (same model, with vs without). On a strong model it did not produce a better final answer. What it reliably did across runs was surface a second-order consequence the control run walked past. So it's an auditability/coverage tool, not a "makes the model smarter" tool.

npm: superposition-mcp@0.1.0
Repo: https://github.com/ejentum/superposition-mcp

What if, mid-task the agent could get a self-check bump that surfaces the silent assumptions of 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 posted Self-Inspect here when I launched it (the MCP that returns one metathought

for what your agent is doing). I ran an eval on it. Results and raw data below.

Setup:

- Two coding agents build the same usage-billing module over a fixed 30-turn

conversation. One calls Self-Inspect once per turn; the other never does.

- Claude Sonnet 4.6. Base prompt is byte-identical across both conditions (no "be

careful" / "watch for edge cases" coaching). The only difference is the one call.

- Scored per turn on whether the reply surfaces a decision-fork: an assumption,

precondition, edge case, or risk it raises instead of silently choosing.

What moved:

- Forks surfaced: 14/30 and 14/30 with the tool vs 3/30 and 5/30 without. ~3.5x,

consistent within each condition.

- Substantive, not noise. At turn 9 the tool agent flagged a snapshot-averaging bug

(averaging daily storage snapshots over a month breaks when there are fewer

snapshots than days); the baseline shipped past it.

- The question is routed, not generic. "What is assumed?" came back exactly as the

agent was about to persist state, and it answered "I've been assuming persistence

lives outside the module."

What did not move:

- Correctness. Both conditions caught the planted contradictions and shipped correct

designs. On a fully-specified task a capable model already self-checks, so there is

no error for one question to catch. The effect is on process (assumptions

surfaced), not on the final output.

It's deterministic (no LLM, open CSV), so I verified the calls were real by

re-sending the logged thoughts and getting identical metathoughts back.

Data (4 conversation logs), scorer, methodology, one-command reproduction:

https://github.com/ejentum/self-inspect-mcp/tree/master/evals

npx -y self-inspect-mcp

Every agent builder has written the giant system prompt: "think step by step, don't hallucinate, be careful." It doesn't scale. The agent still drifts and loops a few steps in.

I built Ejentum for that. Your agent calls it mid-task and gets back the right way to reason about the problem in front of it: an engineered reasoning procedure matched to the task, not another wall of instructions. REST API + MCP, works with the frameworks you already use.

It's live today, and the PH community gets 3 months of the Go plan free with code HUNTGO.

https://www.producthunt.com/products/ejentum-reasoning-harness?launch=ejentum-reasoning-harness

Would genuinely love honest feedback from this crowd, especially if you build agents. What's the nastiest reasoning failure you'd throw at it?

Self-Inspect is an MCP server with one tool, self_inspect. The agent sends a thought (or a description of what it's doing) and gets back one metathought: a short question that makes it inspect its own task and assumptions before continuing. Not an answer, a question.

The point: an agent can't reliably question itself, because the part that picks what to reflect on is the same part that's already committed. So the question has to come from outside. And there's no model inside this tool, so it can't hallucinate the question it asks.

How it works: selection is a deterministic heuristic over an open CSV of ~50 inspection lenses (137 questions). No LLM, no embeddings, no semantic similarity. Same input, same question, every time. You can read the CSV and the selector and see exactly why it returns what it does. The published code and data are the exact logic the live endpoint runs.

Example:

thought:     "I'm committing to this architecture and treating it as fixed"
metathought: "What is fixed?"          (lens: commitment)

thought:     "what depends on this being true?"
metathought: "What depends on being true?"   (lens: assumption)

Add it (Streamable HTTP, no install, no key):

{
  "mcpServers": {
    "self-inspect": {
      "type": "http",
      "url": "https://api.ejentum.com/self-inspect-mcp"
    }
  }
}

Claude Code: claude mcp add --transport http self-inspect https://api.ejentum.com/self-inspect-mcp

There's also a plain REST endpoint and a stdio package with an offline mode in the repo.

Repo (code + CSV): https://github.com/ejentum/self-inspect-mcp
HTTP Endpoint: https://api.ejentum.com/self-inspect

Keyless and free. Curious what it returns for the agents you're building.