> For the complete documentation index, see [llms.txt](https://help.newtone.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.newtone.ai/documentation/core-concepts/quality-and-review.md).

# Quality and review

What the quality bar means in practice, how content is checked before it reaches you, and where human approval stays mandatory.

Newtone is built so that content ships ready to publish rather than as a first draft. That claim has a specific operational meaning, and it changes what your team should be doing with its time.

A system that is mostly right still requires a person on every item, which removes no work. The point of encoding your brand up front is to move review from editing to exception handling.

## Proven agentic architecture

Content is not produced by a single pass at a single prompt. A run is broken into steps, each handled by an agent with one narrow job: assembling the product data and guidelines that apply, drafting against the template, checking the draft against your rules and lexicon, and revising the parts that fail.

The reason to build it this way is diagnosis. When a one-shot system produces something wrong, there is nothing to inspect — you can only rewrite the instruction and hope. When a step-based system produces something wrong, the step that failed is identifiable, and the fix lands in your configuration rather than in a prompt nobody can see.

It is also what makes the correction loop work. A reviewer's change can be traced to the stage that produced it, which is how repeated corrections turn into guideline updates instead of permanent manual effort.

## The best models for every language and use case

No single model is best at everything. Performance varies by language, by content type, and by task — the model that writes the strongest English product copy is not necessarily the one that translates most faithfully into Japanese, and neither is necessarily the one best suited to checking output against a rule set.

Newtone selects the model per combination of language, content type and task, and maintains that selection as models change. You do not choose models, and you do not need to revisit your configuration when a better one becomes available: your guidelines describe how your brand writes, not which system writes it. That separation is deliberate — it means model progress reaches your content without a reconfiguration project.

## Agentic quality gates

Before content reaches a person, it passes automated checks derived from your own configuration rather than from a generic quality score. Typically these cover:

* Conformance to your rules, lexicon and glossary
* Template conformance: required fields present, structure and length within range
* Mandatory wording present where a category requires it, forbidden wording absent
* Do-not-translate entries left intact
* For translation, fidelity to the approved source

Items that fail are revised and rechecked until the performance is at the desired level.&#x20;

This is the mechanism behind the claim at the top of the page. Human review is exception handling because the routine failures have already been caught and fixed, leaving your reviewers the cases that genuinely need judgement.

## Where human approval stays mandatory

Regardless of quality, some content should not publish without a named person approving it: regulated claims, legal wording, anything material to pricing or availability, and launch content for a new market.

Those approvals are a policy decision your team owns. Newtone tracks the states and who moved them; deciding which content requires a human is yours.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://help.newtone.ai/documentation/core-concepts/quality-and-review.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
