Documentation | Lexnus

Start here

Three steps from an empty account to your policy being enforced. No implementation project, no configuration call.

1

Build a playbook from a contract you already have

Upload one Word document — a signed contract or your template. Lexnus reads it, extracts the clauses and the standards implicit in the language — the liability cap you accept, the governing law you prefer, the clauses you always include — and drafts a playbook.

A lawyer on your team reviews it, adjusts what is wrong, and publishes. Nothing is enforced until a human publishes it.

2

Analyse a contract against it

Upload counterparty paper, or a contract you already signed. The engine extracts the Smart Fields your rules reference, evaluates every rule, and returns a verdict per rule. A violation quotes the contract language that caused it.

The analysis also carries a compliance score from 0 to 100. Every failed rule costs points, weighted by how much that rule matters. The result is written to the record, tied to the playbook version that produced it.

3

Connect a surface

Point another tool at the same engine. The application, Slack, the REST API, or an AI agent over MCP all ask the same question and get the same answer — because the playbook, not the surface, decides.

See Surfaces for what is live and what is on the roadmap.

Concepts

Eight words carry the whole model. Getting these right makes everything else obvious.

Clause	A unit of contract language your team has approved. Clauses live in the Clause Library. When Lexnus drafts a contract, it assembles it from library clauses and the text written into the playbook — not from whatever a model would write.
Rule	A plain-language condition your policy requires, written once. Aggregate liability must not exceed 1.5x annual contract value. Rules reference Smart Fields, so the comparison is precise rather than interpretive. Each rule also says what happens when it fails: flag it, require approval, or reject the contract.
Playbook	A governed set of rules and clauses that defines one legal policy — your NDA standard, your MSA standard. Every saved edit to a published playbook creates a new version, and every analysis records the version it ran against.
Smart Field	A structured data point extracted from contract text: a cap amount, a notice period, a governing law. The AI extracts the value. The rule evaluates it. A value the model could not read with confidence is left out rather than guessed.
Analysis	One contract evaluated against one playbook. Also the unit Lexnus meters.
Verdict	The result of one rule against one contract. Compliant: the rule is met. Violated: the contract contradicts it. Gap: a required clause is missing. Needs review: the rule cannot be decided from the contract text, so a person decides. The model reads; the rule decides.
Approval	A sign-off a rule can require before a contract moves forward. An approval group decides — any one member, or all of them — and the decision is recorded with the contract.
The record	The history of what was asked, what was answered, who decided, and which playbook version answered it. This is what makes a decision defensible a year later.

After the analysis

A verdict is where the policy stops and the work starts. The same contract record carries it through to signature and beyond.

ApprovalsA rule that requires approval sends the contract to the right group. Approvers decide in the application or straight from Slack.

Signing and obligationsSend for e-signature, track who has signed, and keep the dates and duties the contract creates in front of the people who own them.

VersionsEvery revision of a contract is a new version, checked again against the playbook.

IntegrationsSlack, webhooks, single sign-on, user provisioning and the REST API.

Surfaces

A surface is anywhere a contract question can be asked. Every surface calls the same engine, so the answer does not change with the tool.

Lexnus applicationBuild playbooks, run analyses, approve, send for signature, and browse the record. The full interface, with Lex, the built-in assistant.

SlackApproval requests with Approve and Reject buttons, notifications, and Lex in a direct message.

MCP-connected agentsClaude, ChatGPT, Mistral and any other MCP client. 27 tools. Reference.

REST APIThe same API the application uses, called with a developer token or an OAuth token. Every call runs with the role of the person behind the token.

WebhooksSigned HTTP callbacks when something happens in Lexnus, so your own systems can react.

Word and Outlook add-insRoadmapAnalyse inside the document and check attached paper without leaving the mail client.

API and MCP reference

The MCP reference is the complete technical document: all 27 tools with JSON Schema, the authentication model, scopes, rate limits and what the audit log records for every call. The essentials:

Server URL	`https://app.lexnus.com/mcp`
Transport	Streamable HTTP. Stateless — every call is authenticated independently.
Authentication	OAuth 2.1 authorisation code flow with PKCE, or a developer token created under Account settings → Developers
Scopes	`lexnous:read`, `lexnous:write`
Tools	27 — fifteen need the read scope, twelve need write
Tool manifest	`GET https://app.lexnus.com/mcp/tools`, with a token
Rate limit	5 requests per second sustained per account, burst 20
Analysis	Asynchronous by default: start it, then read the result. Pass `wait_seconds` (up to 40) to get the result in the same call.

The REST API accepts the same developer and OAuth tokens. Scopes are checked on MCP tool calls; on the REST API, what a token can do is set by the role of the person who created it. MCP integration overview covers the MCP side for a non-engineering reader.

Feature guides

Legal PlaybooksHow rules are written, versioned and published.

Contract AnalysisWhat happens to a contract, rule by rule.

Clause LibraryGoverning the language itself.

Contract DraftingAssembling outbound paper from your clauses and playbook text.

ApprovalsWho signs off when a rule says someone must.

Signing and ObligationsFrom agreed to signed, and what the contract asks of you after.

IntegrationsWhat connects to Lexnus today, and what is next.

MCP IntegrationConnecting AI tools to your policy.

AI speed without AI riskWhy the model reads and the playbook decides.

Security and legal

SecurityEU hosting, every sub-processor named, the audit record, and what is agreed per contract.

Data Processing AddendumThe binding sub-processor list and processing terms.

Privacy PolicyWhat we collect and why.

Terms of ServiceThe contracting terms.