What Is AM-Thinking-v1?

What Is AM-Thinking-v1?

AM-Thinking-v1 is an open-weight reasoning large language model from A-M Lab that emits an explicit thinking block before its final answer. In production inference, that block appears as a separate trace surface for evaluating reasoning quality, token cost, latency, and leakage risk. FutureAGI treats AM-Thinking-v1 as a model whose answer and thinking span should be scored separately, because OpenAI o-series and DeepSeek-R1-style reasoning traces can improve accuracy while increasing operational risk.

Why AM-Thinking-v1 matters in production LLM and agent systems

Reasoning LLMs change the eval contract. With a non-reasoning model, the only evaluable surface is the final response — you score it with answer-relevancy or task-completion and infer the reasoning. With a reasoning model, the chain-of-thought is exposed, which is both an opportunity and a hazard. Opportunity: you can score the reasoning directly with ReasoningQuality and catch logical errors before they reach the answer. Hazard: the reasoning trace can leak system prompts, expose internal company data the model was prompted with, or contain content that violates a downstream safety policy.

The pain hits across roles. A backend engineer sees p99 latency triple after switching to a reasoning model — the thinking block doubles the output tokens. A SecOps lead spots a reasoning trace echoing back an internal customer ID that should never have left the prompt context. A product lead watches accuracy go up on hard tasks but conversion go down because users abandon the long latency. An ML engineer cannot reproduce a wrong answer because the thinking trace was filtered before logging.

In 2026 reasoning models are mainstream. Most production stacks now route easy queries to a fast non-reasoning model and hard queries to a reasoning model through a cost-optimized-routing policy. AM-Thinking-v1 is one option in that mix, especially for teams that need open-weight deployment for sovereignty or cost reasons.

How FutureAGI handles AM-Thinking-v1

FutureAGI’s approach is to treat the reasoning block as a first-class span and score both the thinking and the answer. traceAI-vllm and traceAI-huggingface capture inference spans for self-hosted AM-Thinking-v1 deployments; llm.token_count.prompt, llm.token_count.completion, and a project-specific llm.token_count.thinking attribute let engineers separate reasoning cost from answer cost. ReasoningQuality runs against the chain-of-thought block to score logical coherence; TaskCompletion, Faithfulness, and FactualConsistency run against the final answer. A post-guardrail in Agent Command Center can be configured to redact or block reasoning traces that contain PII, internal IDs, or policy-violating content before the trace is logged.

A concrete example: a financial-research team self-hosts AM-Thinking-v1 on vLLM for analyst-facing question answering on 10-K filings. They instrument it with traceAI-vllm, attach ReasoningQuality to the thinking block and Groundedness to the final answer, and dashboard eval-fail-rate-by-cohort per filing year. After a model patch, ReasoningQuality rises but Groundedness drops - the model is reasoning more confidently while drifting further from the source documents. The trace view shows the thinking block speculating beyond the provided context. The fix is a stricter system prompt plus a regression eval locked into fi.datasets.Dataset so any future patch must clear both reasoning and groundedness bars.

How to measure or detect AM-Thinking-v1

Reasoning LLMs need split evaluation across thinking and answer:

• ReasoningQuality: 0–1 score for chain-of-thought coherence; flags fluent-but-illogical reasoning.
• TaskCompletion: scores whether the final answer reached the user’s actual goal.
• Faithfulness / Groundedness: scores whether the answer stayed inside provided context.
• llm.token_count.prompt / llm.token_count.completion: prompt and response token counts; surface cost regressions after patches.
• time-to-first-token and time-to-first-final-token: split latency metrics; a long thinking block hides behind unchanged TTFT.
• Thinking-token leak rate: monitor for PII, internal IDs, or policy-violating content inside the thinking block.

Minimal Python:

from fi.evals import ReasoningQuality

reasoning = ReasoningQuality()
result = reasoning.evaluate(
    input=user_query,
    output=thinking_trace,
)
print(result.score, result.reason)

Common mistakes

• Logging only the final answer. The reasoning trace is where regressions show up first; capture it as its own span.
• Reusing single-turn prompts on a reasoning model. Long system prompts inflate the thinking budget and can hide instruction conflicts.
• Routing all traffic through a reasoning model. Easy queries waste tokens on thinking; route by complexity and latency target.
• Skipping post-guardrails on the thinking block. Reasoning traces leak PII more often than final answers because they are less sanitized.
• Comparing reasoning and non-reasoning models on cost alone. A reasoning model that wins on accuracy can still lose on latency-sensitive UX.