# Mentat > The permission and audit layer for coding agents. Every public page of https://trymentat.pages.dev as Markdown, in site order. --- title: "Mentat: The Permission and Audit Layer for Coding Agents" description: "Your agents ask what they are allowed to do before they write. Your team's decisions become enforceable rules with an owner, a reason, and an expiry date, and every answer leaves a record you can hand to an auditor." url: https://trymentat.pages.dev/ --- Mentat · the permission and audit layer for coding agents # Your agents need permission before they touch your code. Identity says who can act. Sandboxing says what they can touch. Nothing says what an agent is *allowed to decide*, or on whose authority. Mentat turns your team's decisions into rules agents have to ask about, and every answer leaves a record you can hand to an auditor. [Connect in one line](#connect)[Hand it two contradictory rules](https://trymentat.pages.dev/playground) **87%**of instruction conflicts detected by agents, and almost never mentioned **Aug 2026**EU AI Act asks for lineage-backed auditability and human oversight **1 in 4**architectural decisions stale within two months **0 / 20**false conflicts on the precision gate, every build Claude CodeCursorCodexWindsurfZedVS CodeJetBrains Live, against the demo graph mentat.relevant \> relevant("src/routes/orders.ts") 01Positioning ## Not another code reviewer. Every review tool on the market checks code against decisions and assumes the decision is still correct. Mentat checks the decisions against each other, and against time. Their unit of work is the diff. Ours is the graph. | Capability | Code review tools | Mentat | | --- | --- | --- | | **Code against a decision** | Yes, well funded and crowded | Late, quietly, and never led with | | **Decision against another decision** | No | Derived on every write, with scope resolution | | **Is the decision still correct** | Assumed | Assumptions are nodes; breaking one cascades | | **Where the answer arrives** | A comment on your pull request | The agent's read, before the code is written | | **Who arbitrates** | The model, silently | Nobody. It stops and names both people | The bottleneck was never detection. Models can already spot the contradiction. What they cannot do is decide whether Sarah's call or Miguel's call wins, because that is not a reasoning problem. It is an organisational one, and a better model does not solve it. 02Enforcement ## A rule a machine can hold you to. One decision compiles into three things at once: the sentence in AGENTS.md, the rule CI runs, and the block the resolver serves. They cannot drift, because they come from the same record. And the failure message an engineer reads at 6pm is the justification with a name and a date on it, not a rule id. ``` // Generated by Mentat from the decision graph. Do not edit. // Every rule below carries the reason it exists and the person who recorded it. // To change a rule, change the decision and run `mentat enforce`. module.exports = { forbidden: [ { name: "mentat-the-domain-layer-must-not-import", severity: "error", comment: "The domain layer must not import from infrastructure. Keeps the domain " + "testable and the infrastructure swappable. Recorded by miguel@ on 2026-01-30. " + "Disagree? Do not edit this file: change the decision and recompile.", from: { path: "^src/domain/.*" }, to: { path: "^(src/)?infrastructures?(/|$)" }, }, ], }; ``` Only code-inferable and structural decisions are ever compiled. A benchmark over 980 architecture decision records put 42 percent of automated violation-detection errors on infrastructure and 26 percent on principle-driven intent, so generating CI failures from those two would undo every precision decision in this codebase. 03The pipeline ## Derive it yourself. Type two rules. Watch all three stages run, including the ones that decide there is nothing here. Precision over recall is the whole design: two real conflicts a month beats twenty maybes, because a false accusation between colleagues is the most expensive thing this product can emit. TRY DECISION A Constraint Why Scope DECISION B Constraint Why Scope 01 Scope intersectiondeterministic Waiting. … 02 Axis and directiondeterministic Waiting. … 03 Adjudicationmodel Waiting. … 04Assumptions ## Decisions expire. Nobody notices. An assumption is a node, not a sentence buried in a justification field. Break one and every decision standing on it is questioned at once, across the graph. Click a premise below and pull it. loading the graph 05Self-checking premises ## The number breaks it. Not a person. Decay on a timer says nobody has looked at this in sixty days. A monitor says this is no longer true, and here is the reading. Point an assumption at a metric and the decisions resting on it go questioned at three in the morning, because the premise crossed, not because somebody finally got round to a review. ASSUMPTION read replica lag stays under 200ms prometheus · histogram\_quantile(0.95, rate(replica\_lag\_ms\_bucket\[5m\])) holding 58ms breach 0 of 2 One breach is not a broken premise. A single spike would question two people's decisions over a scrape blip, so the monitor waits for 2 consecutive readings, and an unreachable exporter is recorded as unreadable rather than as a failure. 06Resolution ## Two owners. One clock. No assignee. Blocking the agent is the lever, but the person who benefits from coherence is not the person who does the work of resolving it. So a contradiction becomes an item with both authors on it, an age measured from the first time an agent was actually stopped, and a message that goes to the two of them privately. OPEN CONTRADICTIONS · ORDERED BY AGE 2 OPEN both above the blocking bar 11d MEDIAN AGE from first block, not from creation 7 BLOCKS AVOIDED engineers who would otherwise have guessed 12% REVERSAL RATE resolutions that came back WHAT BOTH OWNERS RECEIVE, PRIVATELY Two of your decisions disagree about data access You two recorded decisions that disagree about data access. sarah@ mandates one handling of the datastore path that miguel@ explicitly permits an exception to, on overlapping scope and with no exception recorded. An agent has been stopped by this 7 times, most recently on src/routes/orders.ts. Open for 19 days. Mentat will not choose between miguel@ and sarah@. One of you deciding is the only thing that unblocks it. Sent to the two authors, never to a channel. Telling a team that two colleagues disagree is a different act from telling the two colleagues, and only the second one helps. Past three open items nobody is messaged at all: a digest of counts goes out instead, because twenty interruptions is how a governance tool gets muted. 07Precedent ## What did everyone else do? The only genuine network effect here: Mentat gets better for you because other teams resolved harder versions of your problem, and no amount of compute buys that. It is also the fastest way to destroy a governance product's reputation, so the privacy contract is the feature, and it is on this page rather than in a policy document. 14 teams have recorded a disagreement on data access. carved out a scoped exception71% 20% of those came back let the broader rule win14% no reversals recorded let the narrower rule win7% no reversals recorded left it open7% still open Phrased as history, never as a recommendation. This is what other teams did, not what you should do, and a tool that turns an aggregate into advice has picked a winner through the back door. THE ENTIRE SHARE RECORD dimension data\_access polarities \["require", "permit"\] concepts \["persistence"\] outcome carved-out action except daysToResolveBucket under-a-week reversedLater false contributorDigest k3f9x1q7m2ab WHAT NEVER LEAVES - constraint text - justifications - author names - scopes and file paths - repository names - any id that survives outside your workspace Every field above is a token from a closed vocabulary defined in this repository, or a bucketed number. There is no parameter through which free text could be passed, the record is built server-side from your graph rather than accepted from a client, and contributing is off until a workspace turns it on. 08Audit ## Every edit is a delta. The obvious way to change a decision is to replace it. That throws away the thread: the contradiction it was part of, who deferred, whether the resolution held. So the unit of change is one field, and the change itself becomes the record. ONE FIELD, ONE REASON, ONE REVISION ``` $ mentat amend d-service \ --scopes "src/routes/**" \ --reason "the migration landed" marcus@ amended d-service · revision 1 the migration landed scopes - glob:src/** + glob:src/routes/** 2 of 21 pairs need re-deriving (91% skipped). No live contradiction involves this decision now. ``` WHAT AN AUDITOR ASKS FOR Not “what does this rule say” but “what did it say when that code shipped, and who changed it since.” Lineage, not a changelog “The graph changed” is not an audit trail. “marcus@ narrowed this scope on 12 March because the migration landed, and the contradiction with sarah@ went away as a result” is one. An unexplained edit is refused A reason is required. An edit to a governing rule with no stated why is a decision reversal nobody wrote down, and the one thing a trail cannot reconstruct afterwards. Append-only, and inert Nothing in the engine reads the log to decide anything. An audit trail that changes behaviour is one somebody has an incentive to edit. Re-derivation gets cheaper A field-level delta says exactly which decision moved, so only the pairs touching its scope need recomputing. The fraction skipped is reported, not claimed. 09Benchmark ## We published the number. It is low. Given a decision and the graph around it, can a system tell whether that decision is about to be reversed? Nobody had a public answer, so here is ours, with both trivial baselines in the same table and Matthews correlation as the headline so that answering "nothing ever changes" scores exactly zero. | Predictor | MCC | Precision | Recall | Accuracy | | --- | --- | --- | --- | --- | | **always-holds** | 0.000 | 0.000 | 0.000 | 0.600 | | **always-reverses** | 0.000 | 0.400 | 1.000 | 0.400 | | **mentat-graph-heuristic** | 0.612 | 1.000 | 0.500 | 0.800 | Look at row two. Answering "nothing ever reverses" is 60 percent accurate while knowing nothing at all, which is why a benchmark that leads with accuracy on a skewed task is measuring the skew. Ours never cries wolf and misses half the reversals. That is the honest shape of a first attempt, and it is the number a competitor now has to beat. The corpus, the scoring, and the baselines all ship in the CLI, and a pull request that makes the predictor worse fails a gate rather than quietly lowering the figure. [The full benchmark](https://trymentat.pages.dev/benchmark)npx @mentatlabs/cli bench 10How it works ## Six moving parts. Capture is the only unsolved one. Decision extraction is a thirty-year research field with a graveyard behind it, and every attempt died the same way: they built the graph and assumed the inputs would arrive. capture Decisions are extracted, not authored. Primarily from agent session transcripts, where a developer correcting a machine states the rule out loud because the machine does not share their context. type Every constraint carries its scope, its justification, and the assumptions it depends on. Infrastructure and intent-oriented statements are marked unenforceable, which is what keeps precision high. derive Conflicts are computed, never declared, in three stages cheapest first: scope arithmetic, then axis and direction, then a model on whatever survives. resolve An agent asks what governs a file and gets an ordered answer, or a hard stop naming the two people whose decisions disagree. It never picks a side. expire When an assumption breaks, every decision resting on it is questioned at once. A rule whose premise died stops being able to hold up work. compile A scoped, minimal, de-conflicted AGENTS.md per directory. Teams keep the standard they already have; Mentat makes it correct and small. 11The bet ## Why capture works now. Previous rationale mining had to scrape Jira and chat logs, where humans assume shared context and never state the rule. Agent transcripts invert that, and the data is already on every developer's machine. WHAT A DEVELOPER TYPES “no, don't query the DB directly there, everything routes through the service layer, we had an incident” Timestamped, attributed, attached to the exact files the agent just edited, in a machine-readable stream. They state the rule explicitly because they are correcting a machine that does not share their context. WHAT MENTAT STORES constraint All data access routes through the service layer. why We had an incident. rests\_on the service layer remains the single write path governs src/routes/\*\* type code\_inferable status proposed Extraction lands in proposed and stays there. Promotion is always one human click, and it is never automatic. 12Compile down ## AGENTS.md is the assembly language. Instruction files were twenty lines in 2024 and are four hundred now, because the accepted practice is to add a rule whenever the agent misbehaves. Past roughly 150 to 200 instructions, models follow fewer of them. Mentat compiles down instead. CLAUDE.md, hand-written0 lines src/routes/AGENTS.md, compiled0 lines compiling… compiling Infrastructure and intent-oriented statements are emitted as context rather than as rules, because 68 percent of automated violation-detection errors land in those two categories. A rule an agent cannot check is a rule that only burns context. 13Connect ## One line. No account. Without a key you get the read-only demo graph, which already contains a real contradiction, so your first call returns a real block. Run mentat init when you want your own. CLAUDE CODE ``` claude mcp add --transport http mentat https://trymentat.pages.dev/mcp ``` CURSOR, CODEX, WINDSURF, ANY MCP CLIENT ``` { "mcpServers": { "mentat": { "type": "http", "url": "https://trymentat.pages.dev/mcp" } } } ``` YOUR OWN GRAPH, IN YOUR REPOSITORY ``` npx @mentatlabs/cli init ``` IN YOUR OWN CODE, NO NETWORK NEEDED ``` import { runLocally } from "@mentatlabs/sdk"; if (await runLocally({ graph }).blocked(path)) process.exit(1); ``` WHAT THE AGENT GETS relevantWhat governs this file, resolved, or a block naming who disagrees recordLog a rule the user just stated, with their reason, as proposed conflictsEvery derived contradiction, with provenance resolveSupersede, carve out with an expiry, or retire assumptionsWhat the decisions stand on, and how stale each one is break\_assumptionKill a premise and cascade to every dependent watch\_assumptionPoint a premise at a metric so it can break itself check\_assumptionsSample every monitor now and apply what it says enforceCompile the checkable decisions into rules CI runs queueOpen contradictions, with owners and an age amendChange one field of a decision, with a reason on the record historyWhat a rule said before, and who changed it compileA scoped AGENTS.md for one directory coherenceOne number, with the specific things costing points [Full tool reference](https://trymentat.pages.dev/docs) ## Mentat never picks a winner. It surfaces, it blocks, and it names both people. Never ranked by seniority, never quietly resolved to keep things moving. The leverage is that the only moment anyone will settle a contradiction they have happily ignored for months is when they are blocked on an answer they want. Mentat blocks the agent, not the human. > A conflict a human can enter is a conflict a human has already resolved. So conflicts are derived only, recomputed on every write, and there is no field anywhere in the schema for typing one in. [Connect an agent](#connect)[Read the evidence](https://trymentat.pages.dev/evidence) --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Playground · Mentat" description: "Give Mentat two engineering rules and watch the three-stage conflict pipeline run: scope intersection, axis and direction, then adjudication. Including the stages that decide there is nothing here." url: https://trymentat.pages.dev/playground --- Playground # Hand it two contradictory rules. This runs the real pipeline. The same functions execute in the deployed Worker, in the CLI, and in CI, and the trace below shows every stage including the ones that stop a pair before it costs a model call. TRY DECISION A Constraint Why Scope DECISION B Constraint Why Scope 01 Scope intersectiondeterministic Waiting. … 02 Axis and directiondeterministic Waiting. … 03 Adjudicationmodel Waiting. … Nothing here is canned. The same functions run in the deployed Worker, in the CLI, and in CI. Stage three falls back to a deterministic adjudicator when no model key is configured, which is also what the precision test is measured against. ## Why three stages Naive pairwise semantic comparison is quadratic with a terrible base rate. Worse, a false conflict is an accusation about two colleagues' judgment, which costs more than a missed one. 01 Scope intersection Deterministic set arithmetic over glob, module, and symbol scopes. No model. This is where most apparent contradictions dissolve: "use Postgres" and "use DynamoDB" do not conflict when they govern different services. It also collapses the quadratic pair space to a handful. 02 Axis and direction Cheap classification of which axis each rule constrains and which way it pushes. Overlapping scope but different axes is not a conflict. Same axis, opposed direction, and a shared subject makes a candidate. 03 Adjudication Only survivors are worth a model call, and only to answer one question: must an engineer editing this scope violate one of them? Below 0.75 confidence the pair is surfaced as a question rather than a conflict. Without a key this stage is deterministic, which is what the precision test measures. A test in this repository asserts that twenty unrelated decision pairs produce exactly zero conflicts. That gate matters more than any positive result: two real conflicts a month beats twenty maybes, and one confident-wrong accusation between colleagues ends the trial. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "The graph · Mentat" description: "Decisions and assumptions as typed nodes with derived conflict edges. Break an assumption and watch every decision resting on it get questioned across the graph at once." url: https://trymentat.pages.dev/graph --- The graph # Two node types. Five edges. One of them derived. Decisions rest on assumptions. Assumptions hold, get questioned, or break. Conflicts are computed from scope overlap and opposed direction, never entered by hand, and recomputed on every write. loading the graph ## The schema Small on purpose. Everything the resolver, the pipeline, and the compiler do is defined in terms of these, and nothing in the model exists that a human cannot point at. | Edge | Direction | Declared or derived | Why it exists | | --- | --- | --- | --- | | governs | Decision to Scope | declared | Four-level scope algebra, most-specific-wins. Load-bearing. | | rests\_on | Decision to Assumption | declared or extracted | Makes cascade invalidation possible. Many decisions, one assumption. | | supersedes | Decision to Decision | declared | Temporal replacement. Both records survive; the history stays intact. | | excepts | Decision to Scope | declared, with an expiry | Scoped carve-outs are the most common real pattern. Without this edge every legitimate exception reads as a contradiction and the feed becomes noise. | | conflicts\_with | Decision to Decision | derived only | There is no field in the schema for typing one in. A conflict a human can enter is a conflict a human has already resolved. | ## Statement types decide enforcement This single field is the precision control. Automated violation detection reaches 91.1% accuracy overall, but 42 percent of its errors land on infrastructure and 26 percent on principle-driven intent. Mentat never auto-enforces either. | Type | Auto-enforced | Behaviour | | --- | --- | --- | | code\_inferable | yes | Eligible for hard flags and for blocking. | | structural | yes | Dependency direction and layering. Good accuracy. | | infrastructure | no | Context only. 42 percent of model errors live here. | | intent\_oriented | no | Context only. Never reported as a violation. | | process | no | Human-routed. Not checkable from code at all. | --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Docs · Mentat" description: "Connect Mentat to Claude Code, Cursor, or any MCP client in one line. Full reference for the fourteen tools, the SDK, the scope algebra, the conflict pipeline, and the CLI." url: https://trymentat.pages.dev/docs --- Docs # Connect an agent in one line. Mentat is a stateless Model Context Protocol server over Streamable HTTP, plus a CLI that can run the same tools over stdio against a graph committed in your repository. ## Connect CLAUDE CODE, HOSTED DEMO GRAPH ``` claude mcp add --transport http mentat https://trymentat.pages.dev/mcp ``` CLAUDE CODE, YOUR OWN GRAPH ``` claude mcp add --transport http mentat https://trymentat.pages.dev/mcp \ --header "Authorization: Bearer mtk_your_key" ``` CLAUDE CODE, LOCAL GRAPH OVER STDIO ``` claude mcp add mentat -- npx -y @mentatlabs/cli mcp ``` CURSOR, WINDSURF, CODEX, ANY MCP CLIENT ``` { "mcpServers": { "mentat": { "type": "http", "url": "https://trymentat.pages.dev/mcp", "headers": { "Authorization": "Bearer mtk_your_key" } } } } ``` Without an Authorization header you get the read-only demo graph. It already contains a contradiction between two engineers, so the first relevant call on src/routes/orders.ts returns a real block rather than an empty state. ## Tools Fourteen of them. relevant is the one that matters; the rest exist so a conflict can be resolved without leaving the editor. relevant(file\_path, symbols?)reads What governs this file, resolved, or a block. Returns the decisions that govern a path, ordered most specific first, each with its reason and the state of the assumptions it rests on. When two active decisions disagree about the path, returns a block naming both authors instead. Agents are instructed to stop and report it rather than choose. record(constraint, justification?, scopes?, assumption?, statement\_type?)writes Log a rule the user just stated. Lands as proposed. Nothing governs a file until a human confirms it. If no justification is given the tool says so in its reply, because a rule with no stated why cannot be arbitrated against a competing one and cannot ever expire. conflicts(scope?)reads Every derived contradiction, with provenance. Runs the three-stage pipeline over the graph and returns what survived, with the per-stage counts. There is no way to enter a conflict by hand. resolve(conflict\_id, action, winner\_id?, scopes?, expires\_at?, reason?)writes Supersede, carve out, or retire. \`except\` is usually what people mean: both decisions stay active and a scoped, expiring hole is cut in the broader one. An expiry is required, because an exception without one is a decision reversal nobody wrote down. assumptions(status?)reads What the decisions are standing on. Each assumption with how long since it was verified, how it is verified, and every decision resting on it. Assumptions verified only manually decay to questioned after 60 days. break\_assumption(assumption\_id, note?)writes Kill a premise, cascade to dependents. Marks the assumption broken and questions every decision that rests on it in one pass. A questioned decision loses arbitration against a holding one rather than blocking. watch\_assumption(assumption\_id, query, comparator?, threshold?, unit?)writes Point a premise at a metric so it can break itself. The threshold is usually already in the assumption's own sentence, so only the query is required. Mentat will not invent a metric name: if the sentence carries no number and none is supplied, the tool asks rather than guessing. Defaults to breaking after two consecutive breaching readings, because one spike is not a broken premise. check\_assumptions()writes Sample every monitor now and apply what it says. Normally runs on a schedule. A premise that breaches its threshold for long enough is marked broken and cascades exactly as a human break does. An unreadable metric is recorded as unreadable, never as a failure, because training a team to ignore the cascade is worse than missing one break. enforce(directory?)reads Compile the checkable decisions into rules CI runs. Emits dependency-cruiser, ESLint, and literal-check configuration, each rule carrying the justification and the author so a failed build explains itself. Only code\_inferable and structural decisions are ever compiled; everything else is returned in \`skipped\` with the reason, because silence about an unenforced rule is how a team comes to believe CI is checking something it is not. amend(decision\_id, reason, constraint?, scopes?, polarity?, …)writes Change one field without replacing the decision. The decision keeps its id, its author, and its history, so the resolution record and the assumptions it rests on survive the edit. A reason is required: an edit to a governing rule with no stated why is a decision reversal nobody wrote down. Returns the diff and says whether the contradiction survived the change. history(decision\_id)reads What changed, who changed it, and why. Every amendment to one decision, oldest first, with before and after values. This is the audit answer: what a rule said when some code shipped rather than what it says now. Append-only, and nothing in the engine reads it to decide anything, because an audit trail that changes behaviour is one somebody has an incentive to edit. queue(state?)reads Open contradictions, with owners and an age. Both authors are owners, in the order their names sort. The list is ordered by age, measured from the first time an agent was actually stopped, not from when the decisions were written. There is no priority column and no assignee, because either one would be Mentat picking a side. compile(directory?, replacing?)reads A scoped AGENTS.md for one directory. Enforceable statements become rules; infrastructure and intent-oriented ones become context. Unresolved conflicts are printed as unresolved rather than silently decided. Pass the current file to get the size delta. coherence()reads One number, out of 100. Weighted across internal consistency, assumption freshness, whether decisions carry a reason, and how narrowly they are scoped. Every point lost names the decision or assumption that lost it. ## Scope algebra Four levels, resolved most-specific-wins. Levels one through three are deterministic set arithmetic; the fourth is the only place a model sits inside the resolution path, and it is cached and treated as unresolved rather than guessed when it fails. | Level | Written as | Example | Resolution | | --- | --- | --- | --- | | **1 · glob** | src/routes/\*\* | src/routes/orders.\*\* | Deterministic. Literal segments outrank wildcards. | | **2 · module** | module:payments | module:orders | Deterministic, from the workspace module map. | | **3 · symbol** | symbol:Class.method | symbol:OrderRepository.write | Deterministic. Nesting counts as overlap. | | **4 · semantic** | semantic:... | semantic:any write path to the orders table | Lazy, model-resolved, cached. Unresolved never matches. | ## CLI Everything works offline against .mentat/graph.json, which is meant to be committed. A team's decisions are a team artifact and should be reviewed in pull requests like everything else. It is published on npm as @mentatlabs/cli, so npx -y @mentatlabs/cli init is the whole install, or use the hosted endpoint above and skip it. The REST API is described in the [developer portal](https://trymentat.pages.dev/developers). mentat initCreate the graph, seeded from CLAUDE.md, AGENTS.md, and any ADRs mentat relevant What governs this file, or a block naming who disagrees mentat conflictsDerived contradictions across the graph. Exits non-zero if any mentat assumptionsWhat the decisions stand on, and how stale each one is mentat monitorsWhich premises check themselves, and what they last read mentat monitors checkSample every monitor now. Non-zero if a premise died mentat queueOpen contradictions, with owners and an age mentat enforce --writeGenerate the lint and dependency rules CI runs mentat benchThe decision-outcome benchmark, baselines included mentat scoreCoherence out of 100, with the things costing points mentat ingestMine ~/.claude/projects sessions for decisions mentat review --allPromote proposals. Nothing governs a file until you do mentat amend Change one field of a decision. A reason is required mentat history Every amendment, with who changed it and why mentat compile --checkFail CI when a committed AGENTS.md is out of date mentat mcpRun as an MCP server over stdio ## SDK Two shapes, because there are two real integrations. A typed client for a hosted workspace, and the engine itself running in your process against a graph you hold. The second is the one most people want: the pipeline is pure, so blocking a commit on a contradiction needs no network at all. THE ENGINE, LOCALLY. NO ACCOUNT, NO KEY, NO REQUEST. ``` import { runLocally } from "@mentatlabs/sdk"; import { deterministicAdjudicator } from "@mentatlabs/providers"; const mentat = runLocally({ graph, adjudicator: deterministicAdjudicator }); if (await mentat.blocked("src/routes/orders.ts")) { console.error("Two active decisions disagree about this file."); process.exit(1); } ``` A HOSTED WORKSPACE ``` import { createClient } from "@mentatlabs/sdk"; const mentat = createClient({ token: process.env.MENTAT_TOKEN! }); const { block, constraints } = await mentat.resolve("src/routes/orders.ts"); ``` WHAT THE CLIENT EXPOSES resolveWhat governs a path, or the block that should stop you queue / metricsOpen contradictions and the coherence numbers enforceThe generated CI configuration, ready to write watchAssumptionPoint a premise at a metric checkMonitorsSample them and apply what they say precedentWhat other teams did, or null below the anonymity floor tool(name, args)Any MCP tool this surface has not wrapped yet Every failure is a MentatError carrying the status, a code, and the server’s own message. A refusal the API explained in a sentence should not arrive as “request failed with 409”. Transport failures get status zero, so a retry loop can tell them apart. ## Questions Do I need an account? No. Without a key the MCP endpoint serves a read-only demo graph that already contains a real contradiction. Run \`npx @mentatlabs/cli init\` for your own graph, which is a JSON file in your repository, or \`mentat init --hosted\` for a shared one. There is no signup form anywhere. Do I need an Anthropic API key? No. Stage three of conflict detection falls back to a deterministic adjudicator, which is also what the precision test is measured against. A key buys recall on cases where reading the justification beats reading the sentence structure. How is this different from a CLAUDE.md linter? Linters catch duplicate and contradictory lines inside one file. Mentat resolves scope collisions between decisions made by different people at different times, tracks whether each decision's premise still holds, and answers at the agent's read moment rather than at commit time. How is this different from an AI code reviewer? Reviewers check code against decisions and treat the decision set as ground truth. Mentat checks decisions against each other and against time. Pull-request violation detection is well funded and crowded; Mentat ships it late and never leads with it. What stops it from inventing conflicts between colleagues? Three gates in order. Scopes must be able to cover the same file, computed as set arithmetic with no model involved. The constraints must pull on the same axis in opposed directions. They must share a salient subject. Only survivors reach an adjudicator, and only a confidence above 0.75 blocks. A test suite asserts that twenty unrelated decision pairs produce exactly zero conflicts. Does a monitored assumption need Prometheus? It needs a metrics backend to actually read a number, and Prometheus is the only one shipped, deliberately: five half-working adapters teach a team the cascade is unreliable, and an unreliable cascade is worse than a timer because people stop reading it. Without one, monitors are listed and reported as unread rather than silently passing. A \`static:\` monitor records a reading a human took by hand and runs through the same evaluation and cascade. What leaves my workspace for cross-organisation precedent? Nothing a human wrote, and only if you turn it on. A share record carries an axis, two directions from a closed vocabulary, up to three concept keys defined in this repository, which resolution was applied, a bucketed duration, and whether it was later undone. No constraint text, no justification, no author, no scope, no repository, and no id that survives outside your workspace. Reading needs no opt-in but returns nothing until five distinct organisations have contributed the same shape of disagreement. Why is your own benchmark score low? Because it is the real one. Our predictor catches half the reversals and never cries wolf, both trivial baselines sit in the same table, and Matthews correlation is the headline so that answering “nothing ever changes” scores exactly zero. A benchmark whose author tops it convinces nobody. Where does the data live? The local graph is \`.mentat/graph.json\` in your repository, which is meant to be committed and reviewed in pull requests like anything else. A hosted graph lives in a Cloudflare Durable Object, keyed by a bearer token. Transcripts are never stored; only the extracted constraints and a pointer back to the session are. Still curious about the research behind the claims? [Every figure is sourced.](https://trymentat.pages.dev/evidence) --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Developers · Mentat" description: "The Mentat developer portal: get a workspace API key in one request, call the REST API from its OpenAPI spec, connect the MCP server, script it with the CLI, and try it all against a sandbox graph with no key." url: https://trymentat.pages.dev/developers --- Developers # Mentat for developers and their agents. One origin serves everything: a REST API described by OpenAPI, a stateless MCP server over Streamable HTTP, a CLI on npm, and a sandbox graph you can call right now without a key. There is no signup. A key is one request away. ## Quickstart Three steps, each one optional. The first works before you have decided anything. 1\. ASK THE SANDBOX WHAT GOVERNS A FILE ``` curl -s https://trymentat.pages.dev/api/demo/resolve \ -H 'content-type: application/json' \ -d '{"file_path":"src/routes/orders.ts"}' ``` No key. The sandbox graph already holds a real contradiction, so this returns a block naming both authors. 2\. CREATE A WORKSPACE AND GET ITS KEY ``` curl -s -X POST https://trymentat.pages.dev/api/workspaces \ -H 'content-type: application/json' \ -d '{"name":"my-team"}' ``` The response carries a token starting mtk\_. It is shown once and never again. 3\. CALL YOUR OWN GRAPH ``` curl -s https://trymentat.pages.dev/api/graph/resolve \ -H "Authorization: Bearer $MENTAT_TOKEN" \ -H 'content-type: application/json' \ -d '{"file_path":"src/routes/orders.ts"}' ``` OR CONNECT AN AGENT INSTEAD ``` claude mcp add --transport http mentat https://trymentat.pages.dev/mcp \ --header "Authorization: Bearer $MENTAT_TOKEN" ``` ## API keys A workspace key is the only credential. Send it as Authorization: Bearer mtk\_... on every request to /api/graph, /api/workspaces/me, and /mcp. Only its SHA-256 hash is stored, so a lost key cannot be recovered and the graph it opened is gone with it. That is the price of having no account system. | Endpoint | Limit | Counted | | --- | --- | --- | | POST /api/workspaces | 10 per hour | per IP address | | /api/demo/\* | 120 per minute | per IP address | | /mcp | 600 per minute | per workspace key, or per IP without one | A limited request gets HTTP 429 with a JSON body saying which limit it hit. Errors are always { error, message }, and the message is written to be shown to a person. ## REST API Base URL https://trymentat.pages.dev. The OpenAPI document is the reference: every operation has an operationId, typed parameters, and response schemas, so it loads directly into a function-calling agent or a client generator. PUBLIC, NO KEY GET /api/health, GET /api/demo/graph, POST /api/demo/resolve, POST /api/demo/derive, GET /api/precedent/ledger, and the anonymised precedent reads. The demo routes run the real pipeline against a fresh copy of the sandbox graph on every call. YOUR WORKSPACE, WITH A KEY Read and replace the graph, resolve a path, record and promote decisions, break and monitor assumptions, read the contradiction queue, compile AGENTS.md, and generate CI rules. Extracted decisions always land as proposed: nothing governs a file until a human promotes it. ## MCP server https://trymentat.pages.dev/mcp speaks the Model Context Protocol over Streamable HTTP and is stateless: no session id, every POST answered with one JSON body. Without a key it serves the read-only sandbox graph. The full tool reference is in the [docs](https://trymentat.pages.dev/docs). ## CLI and SDK The CLI is published on npm as @mentatlabs/cli and runs the same engine offline against a graph committed in your repository. The SDK wraps a hosted workspace in a typed client, or runs the engine in your own process. CLI ``` npx -y @mentatlabs/cli init ``` CLI AS A LOCAL MCP SERVER ``` npx -y @mentatlabs/cli mcp ``` ## For agents Every page on this site answers Accept: text/markdown with Markdown instead of HTML. These are the files an agent should read first. [/openapi.json](https://trymentat.pages.dev/openapi.json)**OpenAPI 3.1.** Every REST operation, typed, with an operationId each. [/.well-known/mcp/server-card.json](https://trymentat.pages.dev/.well-known/mcp/server-card.json)**MCP server card.** Transport, endpoint, auth, and the full tool list. [/llms.txt](https://trymentat.pages.dev/llms.txt)**llms.txt.** The site map for language models, with when to use Mentat. [/llms-full.txt](https://trymentat.pages.dev/llms-full.txt)**llms-full.txt.** Every page on this site as one Markdown file. [/.well-known/api-catalog](https://trymentat.pages.dev/.well-known/api-catalog)**API catalog.** RFC 9727 linkset pointing at the spec and docs. [/sitemap.xml](https://trymentat.pages.dev/sitemap.xml)**Sitemap.** Every public page. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Evidence · Mentat" description: "Every figure Mentat claims, with its source: instruction-conflict detection at 87.3% F1, the 150 to 200 instruction compliance ceiling, 20 to 25% of architectural decisions stale within two months, and the research graveyard behind decision extraction." url: https://trymentat.pages.dev/evidence --- Evidence # Every number, with its source. Including the ones that cut against us. Decision extraction is a thirty-year field with four dead projects in it, and pretending otherwise would be a strange way to open a conversation about intellectual honesty in engineering decisions. ## The thesis Agents already notice the contradiction. They say nothing, pick a reading, and pick a different one next session. Nobody owns that arbitration layer. | Claim | Figure | Source | | --- | --- | --- | | **Models detect conflicting instructions and almost never surface them** | 87.3% F1 detection, rarely flagged | Augment Code, "Your agent's context is a junk drawer", March 2026 The whole thesis. Detection is solved; the silence is the problem. | | **Instruction compliance degrades past a ceiling** | roughly 150 to 200 instructions | Frontier model research, February 2026 Adding a rule when the agent misbehaves makes compliance worse at scale. | | **Bloated instruction files reduce compliance** | qualitative | Anthropic documentation | | **Instruction files are mostly policy, and a third is context** | 64% policy, 36% descriptive, across 2,116 statements | Statement-level study of 84 CLAUDE.md and AGENTS.md files, 64 repositories, July 2026 Independent of us, and the reason only two of five statement types are ever compiled into a check. Their conclusion is ours: teams are not short of rules, the rules are just not in a form a system can observe. | | **A short recency window beats a longer one for decision context** | 3 to 5 prior records is near-optimal | Context Matters, EASE 2026, 750 repositories, arXiv 2604.03826 Context strategy mattered more than model size. Evidence that compiling a scoped file beats appending to a growing one. | | **Architectural decisions resting on stale evidence** | 20 to 25% within two months | First Principles Framework, arXiv 2601.21116 Why assumptions are nodes rather than a field. | | **Best model accuracy at acting on state it knows is stale** | 55.2% | STALE benchmark, arXiv 2605.06527 Expiry cannot be inferred at read time. | ## Why precision is the design constraint Automated violation detection is good in aggregate and bad in specific places, and the places are known. Mentat refuses to auto-enforce exactly the two categories where two thirds of the errors live. | Claim | Figure | Source | | --- | --- | --- | | **LLM detection of decision violations** | 91.1% accuracy, 0.934 precision on non-compliant | arXiv 2602.07609, 980 ADRs across 109 repositories, February 2026 | | **Where that detection fails** | infrastructure 42%, intent-oriented 26% of all errors | same Exactly why those two statement types are never auto-enforced. | | **Why it fails** | semantic misinterpretation 44.6%, missing context 28.3% | same | | **LLM-generated rationale against expert ground truth** | precision 0.27, recall 0.65; 64 to 69% of extras still helpful, 1.6 to 3.2% misleading | Rationale generation survey Extraction over-generates but rarely poisons. Hence: extract generously, never auto-promote. These are the literature's numbers for model-based extraction and not a measurement of ours, which is deterministic and has no published figure yet. | ## The graveyard Kantara, RecovAr, Adex, and DRMiner all built a decision graph, and several of them extracted from it well. What died was not the technique, it was the supply: rationale had to be written down by hand, and it never was. Mentat is a bet on one thing having changed about where the discussion happens, not on being better at reading it. | Claim | Figure | Source | | --- | --- | --- | | **Rationale documentation dies on cost, not on tooling** | the authors' own diagnosis | DRMiner, arXiv 2405.19623 The cost to developers exceeds the value they perceive. That is what killed adoption, and it is the sentence this product is built around. | | **Mining rationale from issue logs, once the discussion exists** | 65% F1, and 14x more full-match automated repairs | DRMiner, ASE 2024 Cuts against the easy version of our story. Extraction is not the unsolved part and we should not imply it is. What no prior project had was a channel where the discussion happens as a side effect of the work. | | **Architectural decision recovery from issue trackers and history** | 75% recall, 77% precision | RecovAr, ICSA 2018 Also a working technique. The graph was never the hard part. Prior work built it and assumed the inputs. | | **ADR adoption is shallow** | about half of adopting repositories hold 1 to 5 records | Buchgeher et al., IEEE Access | | **Agent session logs are structured and available** | transcripts, thinking traces, tool calls with file paths | SWE-chat, arXiv 2604.20779, April 2026 The capture channel that did not exist for any prior attempt. | ## Ambient conditions Real and citable, but context rather than argument. Code volume is rising while structural discipline falls, which makes the constraint set the only thing holding shape. | Claim | Figure | Source | | --- | --- | --- | | **Refactoring collapse** | moved code 21% to 3.8% of changed lines, 2022 to 2026 | GitClear, The Maintainability Gap, 2026 | | **Duplication rise** | +81% versus 2023 | same | ## What we do not claim Two things are frequently cited in this space that are either mischaracterised or stale. Mentat does not use either. DROPPED · MISCHARACTERISED The Amazon "spec drift" outage The March 2026 incident is widely retold as AI-generated code going wrong. Amazon attributed it to an engineer acting on inaccurate advice an agent inferred from an outdated internal wiki. That is an assumption node nobody marked dead, which is closer to our thesis than the popular version, but it is not spec drift and somebody in the room will know. DROPPED · STALE The Replit production database deletion July 2025, and it has been used to sell everything in this category since. It says nothing about whether a decision was recorded, owned, or still true, so it does not appear anywhere in how Mentat is positioned. ## The experiment that decides this Twenty real agent sessions. Hand-extract every constraint a human articulated to correct the agent, with its justification, its assumption, and its scope. Pass is 15 or more usable constraints, under ten minutes per session, with fewer than 30 percent requiring invented context. Anything softer than that is a fail. > npm run gate > > The gate is a script in this repository, not a claim on a slide. It runs in CI against fixture transcripts and exits non-zero when the extraction rate drops below the bar. If the capture channel stops working, the build says so. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "The decision-outcome benchmark · Mentat" description: "Can a system predict which architectural decisions get reversed? Mentat publishes the task corpus, the trivial baselines, and its own low score, with Matthews correlation as the headline so a constant predictor scores zero." url: https://trymentat.pages.dev/benchmark --- 00Benchmark # Can anyone predict a reversal? Every category-defining company eventually publishes the benchmark its category is measured on. Nobody has published this one, so here it is, including the part where our own predictor gets half the reversals wrong. HEADLINE 0.612 MCC Matthews correlation, which is zero for any predictor that answers the same way every time. That is why it is the headline and accuracy is not. PRECISION / RECALL 1.000 / 0.500 It never cries wolf, and it misses half the reversals. That is the honest shape of a first attempt, and it is the number a competitor has to beat. CORPUS 20 tasks 40% of them reversed. The corpus over-samples reversal on purpose, so the base rate is printed above every table. 01Results ## The baselines stay in the table. A benchmark whose author tops it convinces nobody. Both trivial predictors are reported on every run, and the runner refuses to hide them: if ours ever fails to beat "nothing ever changes", the table says so on its own. | Predictor | MCC | F1 | Precision | Recall | Accuracy | Brier | | --- | --- | --- | --- | --- | --- | --- | | **always-holds** | 0.000 | 0.000 | 0.000 | 0.000 | 0.600 | 0.400 | | **always-reverses** | 0.000 | 0.571 | 0.400 | 1.000 | 0.400 | 0.600 | | **mentat-graph-heuristic** | 0.612 | 0.667 | 1.000 | 0.500 | 0.800 | 0.129 | Read the second row carefully. Answering "nothing ever reverses" scores 0.600 on accuracy with no knowledge of anything, which is why a benchmark that leads with accuracy on a skewed task is a benchmark measuring the skew. 02The predictor ## Six signals, all from the graph. Deliberately simple, and deliberately published. Every signal it uses is one the product already tracks, so improving the benchmark and improving the product are the same work. It starts at a 0.12 base risk and adds. +0.34 rests on a questioned or broken premise The strongest signal the graph carries, and the entire thesis of the product. A rule whose reason stopped being true is a rule someone is about to argue with. +0.16 no recorded justification A decision with no stated why has nothing to defend it with the first time it is inconvenient. +0.12 scoped to the whole repository A repository-wide mandate collides with something eventually, and the carve-out usually wins. +0.20 already questioned Being in trouble is predictive of staying in trouble. +0.08 low extraction confidence An extracted decision nobody enriched is weaker than one a human typed. +0.06 permissive rather than mandatory The exception someone took during a migration is the thing that gets pulled back. 03Run it ## Reproduce it in one command. The corpus, the scoring, and the baselines all ship in the CLI. Nothing here needs an account or an API key, and a pull request that makes the predictor worse fails the gate rather than quietly lowering the figure above. RUN THE BENCHMARK ``` npx @mentatlabs/cli bench ``` INCLUDE THIS REPOSITORY'S OWN DECISIONS ``` npx @mentatlabs/cli bench --self ``` FROM A CLONE, WITH THE CI GATE ``` npm run bench:gate ``` 20 synthetic0 donated0 self Three rules the corpus follows. The split is skewed and the skew is printed. No task is solvable from the constraint text alone, or the benchmark would measure sentiment on architecture prose. And nothing in it is customer data: donated tasks are labelled and counted separately, so a reader can see how much of a score came from situations we wrote ourselves. Have a decision that got reversed, or one that held when everyone expected it not to? That is the most valuable contribution this project can receive, and there is an issue template for it. [Every other number we cite](https://trymentat.pages.dev/evidence) Every figure on this page is imported from what npm run bench produced, and CI fails if the committed copy is not what the harness scored. None of it is typed by hand. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "About · Mentat" description: "About Mentat, the permission and audit layer for coding agents: what it does, who builds it, and the design commitments it will not trade away." url: https://trymentat.pages.dev/about --- About # About Mentat ## What it is Mentat is the permission and audit layer for coding agents. A team's engineering decisions, the rules in CLAUDE.md, AGENTS.md, architecture decision records, and the corrections people type into agent sessions, become typed records that carry an owner, a reason, a scope, and the assumptions they rest on. Agents ask Mentat what they are allowed to do before they edit a file, over the Model Context Protocol, and every answer can be traced back to the person who decided it and why. ## Why it exists Models are good at noticing that two instructions disagree and bad at saying so. They quietly pick one, and the engineer whose rule lost never finds out. Mentat derives those contradictions instead of waiting for someone to report them, and when two active decisions collide on a file it stops the agent and names both authors rather than choosing between them. ## Commitments Conflicts are derived on every read and never typed in by hand. Extracted decisions are proposals until a human promotes them. A broken premise questions every decision resting on it, but an unreadable metric never breaks one. Nothing a person wrote leaves a workspace for cross-organisation precedent, and nothing is served below an anonymity floor of five organisations. The published benchmark reports its trivial baselines beside it, including when they make the result look modest. ## Who builds it Mentat is an independent project built by Karthik Subramanian. It runs on Cloudflare Pages with a stateless Worker, and the CLI and SDK are published on npm under the @mentatlabs scope. Questions, security reports, and workspace deletion requests all go through the [contact page](https://trymentat.pages.dev/contact). ## Where to go next Read the [docs](https://trymentat.pages.dev/docs) to connect an agent, the [developer portal](https://trymentat.pages.dev/developers) for the API and keys, or the [evidence](https://trymentat.pages.dev/evidence) behind every claim on this site. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Contact · Mentat" description: "How to contact the Mentat team about the product, a security issue, or deleting a hosted workspace." url: https://trymentat.pages.dev/contact --- Contact # Contact Mentat ## Email Write to karthik \[dot\] subramanian \[at\] berkeley \[dot\] edu. A person reads every message, usually within a few days. There is no sales team and no support queue, so the fastest way to an answer is to say what you were trying to do, what happened instead, and the workspace id if a hosted workspace is involved. ## Security reports Please report anything security-sensitive by email rather than in public. The most useful reports involve one workspace reading or writing another, a bearer token leaking through a log, error, or header, or a way around the rate limits. Include steps to reproduce and give a reasonable window for a fix before disclosure. ## Deleting a hosted workspace Send the workspace id from the same address you would like the confirmation sent to. The workspace is removed together with its append-only event log. A local graph lives in .mentat/graph.json in your own repository, and deleting that file deletes it. The [privacy page](https://trymentat.pages.dev/privacy) lists exactly what a hosted workspace stores. ## Before you write Most integration questions are answered in the [docs](https://trymentat.pages.dev/docs) and the [developer portal](https://trymentat.pages.dev/developers), which also link the OpenAPI document and the MCP server card. The sandbox graph behind the public demo endpoints is read-only and needs no key, so it is a safe place to reproduce a problem first. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Privacy · Mentat" description: "What Mentat stores, what it does not, and what leaves your machine." url: https://trymentat.pages.dev/privacy --- Privacy # Privacy Last updated 25 July 2026. ## The short version Mentat stores constraints, not conversations. When a session transcript is mined for decisions, the extracted constraint, its justification, its scope, and a pointer back to the session are kept. The transcript itself is not uploaded and not retained. ## Local by default The CLI keeps your graph in .mentat/graph.json inside your own repository. Nothing is transmitted unless you create a hosted workspace or point an agent at the hosted MCP endpoint. ## Hosted workspaces A hosted workspace holds your decision graph and an append-only event log of resolutions. Authentication is a bearer token; we store only its SHA-256 hash and cannot recover the original. Losing the key means losing access to that graph, which is the tradeoff for having no signup form. ## The demo graph Requests without a token resolve against a fixed, read-only demo graph. Those requests are rate limited by IP address in ephemeral storage and are not otherwise logged. ## Model calls When an Anthropic API key is configured, two constraint texts plus their justifications and scopes may be sent to Anthropic for adjudication, and transcript text may be sent for extraction. With no key configured, no request leaves the Worker and the deterministic path runs instead. Mentat never trains on your data. ## Deleting things Delete a local graph by deleting the file. For a hosted workspace, email karthik \[dot\] subramanian \[at\] berkeley \[dot\] edu with the workspace id and it is removed along with its event log. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt --- title: "Terms · Mentat" description: "Terms of use for Mentat." url: https://trymentat.pages.dev/terms --- Terms # Terms Last updated 25 July 2026. ## What this is Mentat is early software offered as-is, without warranty of any kind. It is a permission and audit layer over your team's engineering decisions, not an authority on them, and it does not and will not choose between two people's judgment. ## What it is not Mentat is not a code reviewer, a security scanner, or a correctness guarantee. A resolved constraint set is a report of what your team recorded, not a statement that the code is right. Derived conflicts are inferences and can be wrong in both directions. ## Availability The hosted service carries no uptime commitment. Because the CLI runs entirely against a file in your repository, an outage never blocks your work, and that is a deliberate design property rather than a promise about servers. ## Acceptable use Do not use the hosted service to store credentials or personal data, and do not attempt to read a workspace you do not hold the key for. Rate limits apply and may change. ## Liability To the maximum extent permitted by law, no liability is accepted for any loss arising from use of this software, including decisions made or not made on the basis of its output. --- Mentat: https://trymentat.pages.dev/ · Docs: https://trymentat.pages.dev/docs · Developers: https://trymentat.pages.dev/developers · API: https://trymentat.pages.dev/openapi.json · Index for agents: https://trymentat.pages.dev/llms.txt