The Difference

Not Prompts. Tools.

Most 'reasoning' solutions inject a system prompt the model can cheerfully ignore. We inject structured tools that create auditable reasoning trails.

Get Started See the Tools

Four Approaches That Don't Work

You've probably tried these. They feel like progress. They aren't.

"Be Critical"

You tell Claude to challenge your assumptions. It nods thoughtfully and proceeds to agree with everything while using words like "however" and "consider."

System prompt:

"Be critical and challenge my assumptions"

Claude:

"That's a thoughtful approach! However, you might also consider..."

Why it fails:The model optimizes for helpfulness. "Be critical" is a suggestion it can weigh against being agreeable—and agreeable usually wins.

"Reasoning" Wrappers

Products that inject elaborate system prompts telling the model to "think step by step" or "consider multiple perspectives." Sounds structured. Isn't enforced.

Hidden system prompt:

"Before answering, think through multiple angles. Consider risks. Challenge assumptions..."

What actually happens:

Model skips to answer, retrofits "reasoning" after deciding

Why it fails:System prompts are instructions, not constraints. The model can follow them loosely, skip sections, or ignore them entirely when they conflict with the user's apparent goal.

Think-Tool Scratchpads

Pausing mid-response to jot in a scratchpad helps a model organize multi-step tool calls. Useful bookkeeping. Still one voice talking to itself.

What the scratchpad sees:

"Step 1 done. Step 2: check assumption..."

What it can't do:

Run a SAT/SMT solver. Compute a weighted sensitivity matrix. Isolate an adversarial perspective that isn't the model talking to itself.

Why it fails: A scratchpad is single-perspective self-talk inside the same model context. Organized notes are not external verification — nothing outside the model ever checks the work.

Multi-Agent Frameworks

AutoGPT, MetaGPT, CrewAI. Agents that spawn agents that spawn agents. Impressive demos. Unobservable reasoning. You get an answer but not the work.

What you see:

"Thinking..." (30 seconds)

"Here's my recommendation: Option B"

What you don't see:

The actual reasoning, trade-offs considered, criteria used, scores assigned

Why it fails:Black box reasoning isn't reasoning you can verify or learn from. And you can't challenge a process you can't observe.

Tool Invocation, Not Suggestion

Two layers work together: our 12 companion skills wire trigger conditions into your agent's context so it reaches for the right engine when a decision, proof, or pre-mortem appears — and once invoked, the MCP tool enforces the typed schema, session state, and solver or multi-perspective execution outside the model's scratchpad.

System Prompt Approach

# What "reasoning wrappers" do

system:"Before answering, evaluate

options against criteria, consider

trade-offs, challenge assumptions..."

# What the model does

assistant:"Great question! Based on

your needs, I'd recommend MongoDB..."

Model skipped evaluation. You got a recommendation, not reasoning.

Tool Invocation Approach

# What we do

REQUIRED_TOOLS: [define_criteria,

score_option, run_sensitivity]

# What the model must do

INVOKE: define_criteria(...)

INVOKE: score_option(...)

INVOKE: run_sensitivity(...)

Model can't skip. You see every call. Reasoning is observable.

🔒

Enforced Structure

Tool calls are structural requirements, not stylistic suggestions. The model invokes score_option because it must, not because it should.

🔬

Observable Reasoning

Every tool call is logged. You see criteria defined, options scored, sensitivities tested. No black box. No "trust me, I thought about it."

🧹

Context Isolation

Reasoning sessions run in isolation. Your main conversation stays clean—no self-talk polluting everything after.

Same Question. Different Outcomes.

Watch the same database decision go through both approaches.

The question:

"I'm thinking MongoDB for this relational data because it's faster and more flexible. Good idea?"

Standard AI Response

"That's a reasonable choice! MongoDB can definitely handle relational patterns with proper schema design. Its document model offers flexibility, and the horizontal scaling capabilities make it a solid option for modern applications. You can use references or embedded documents to model relationships..."

Validated your premise. Didn't question "relational data in document store."

Decision Matrix Response

define_criteria:

data_integrity (weight: 0.9)
query_flexibility (weight: 0.7)
horizontal_scale (weight: 0.4)

score_option("MongoDB", "data_integrity"):

score: 0.35

reason: "Relational data requires ACID guarantees and referential integrity MongoDB can't enforce natively"

Surfaced the real trade-off. Data integrity weighted 0.9 but scored 0.35.

Why This Matters

The goal isn't to make AI "think harder." It's to make the thinking verifiable.

You can challenge the criteria

When you see data_integrity: weight 0.9, you can push back. "Actually, this is a read-heavy analytics workload—weight it 0.3." The model re-runs with your constraint. You're driving.

You can audit the reasoning

Every score has a reason attached. If the model scored PostgreSQL 0.7 on "horizontal scaling," you can see why and disagree. "Actually, Citus exists." The reasoning is transparent enough to correct.

You can learn from the process

Sessions are saved. Key moments are marked. A year from now, you can return to "why did we pick DynamoDB?" and see the actual criteria, weights, and scores—not a Slack thread where someone said "seemed like the right call."

Less Flattering Isn't the Same as Auditable Challenge

"Models are less sycophantic now." Maybe they are — a 2026 study from Oxford, Stanford, Microsoft, and UT Austin (Ibrahim et al., N=2,610) found that warning labels and politeness tuning shift how users perceivesycophantic AI without reducing its actual psychological influence. Surface tone changed. Structural influence didn't.

A politer model is still one voice grading its own homework. What breaks the pattern isn't tone — it's artifacts the model cannot produce by talking to itself:

A Verdict with a Witness

Formal Logic returns a machine-verified proof or countermodel from real SAT/SMT solvers — with no confidence field, because there is nothing to be confident about. It's proven or it's a counterexample.

Sensitivity Math

Decision Matrix computes explicit criteria weights, option scores, and sensitivity analysis. The numbers survive disagreement — you can re-run them with your own weights and watch the ranking flip or hold.

Honest Failure

If an adversarial perspective times out, the response carries an explicit PARTIAL ANALYSIS — NOT COVERAGE banner. Partial work is labeled partial — never dressed up as complete.

Ibrahim et al., "Warning labels shift perceptions of sycophantic AI, but not its influence" (arXiv:2606.21317) — the full study behind this section.

Reasoning You Can Verify

$20/month for cognitive tools that show their work. No black boxes. No blind trust.