> ## Documentation Index
> Fetch the complete documentation index at: https://docs.truemath.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# How TrueMath fits with LLMs

> LLMs reason and parse intent; TrueMath executes the math deterministically. How the two layers work together today, and why the boundary between them is permanent.

Large language models and deterministic math engines are complementary layers, not
competitors. LLMs are extraordinarily good at understanding intent: they parse
natural language, handle ambiguity, and translate a request into structured values.
They are the reasoning layer. TrueMath is the execution layer — it takes those values
and computes the result exactly, the same way every time.

## Division of responsibility

| The LLM handles                             | TrueMath handles                        |
| ------------------------------------------- | --------------------------------------- |
| Understanding a request in natural language | Executing the calculation               |
| Turning it into structured values           | Carrying values at full precision       |
| Explaining a result in prose                | Recording the provenance of every value |
| Drafting domains for review                 | Enforcing versioned business logic      |

The model decides *what* to compute. TrueMath determines *the answer* — and can
account for how it was reached.

## How it works today

You work with TrueMath through the [Playground](/playground/tour) or the
[API](/api/overview), and you choose a [domain](/concepts/domains) to calculate
against. The LLM boundary shows up at one point: **input**.

* **Natural language** — you describe the request in prose. TrueMath uses a language
  model to parse it into structured values and a calculation target, then executes
  deterministically. The model interprets; it never computes.
* **Structured text** — you provide the values directly. No language model is
  involved; TrueMath executes them as given.
* **JSON** — you provide the values as a structured object over the API. Like
  structured text, no language model is involved; TrueMath executes them as given.

See [Input formats](/concepts/input-formats) for all three. Either way, TrueMath returns the
result with every variable's value, unit, and [provenance](/concepts/provenance) — as
raw JSON over the API, or presented visually in the Playground.

## Where this is heading

The same division extends outward as new ways to connect arrive. Through an MCP
interface, a CLI, and client libraries, an external agent or application will be able to
drive TrueMath directly — reasoning about a request, calling TrueMath to execute it, and
narrating the result — without changing what TrueMath itself does. These interfaces are
not available yet; today the connection points are the Playground and the API.

## Why the boundary is permanent

A language model is probabilistic by design: it predicts likely outputs, which is
exactly what makes it powerful at language and reasoning. Mathematics is
deterministic — there is one right answer. A more capable model reasons better; it
does not become a deterministic execution engine. The two are architecturally
different systems, and the right approach is to connect them rather than collapse
them.

This mirrors every trust-critical layer that came before: payment systems execute
transactions exactly rather than approximating them, and database engines return
precise results rather than estimates. TrueMath occupies the same position for
computation in AI workflows.

See [Guarantees](/introduction/guarantees) for what the execution layer gives you.