AI review and assistance

How Ask Alchex answers from your own records and how every AI change leaves a receipt — with billed work and publishing kept on each record's own page.

Alchex's AI works from your own records — documents, controls, risks, evidence — not from general knowledge. The conversational assistant reads them and answers; the checks inside a procedure grade a requirement against the record a run is about.

Ask Alchex

There is one way in: Chat in the sidebar. It is the assistant on its own screen, described under Chat as a screen below, and starter prompts cover the usual questions — Compliance gaps, Open findings, Risk overview, Clause coverage, Generate policy.

To ask about a particular record, pin it with the ⌖ picker in the composer. The conversation is then about that document, register, risk or control until you unpin it, so what is missing here? means that record.

What changed in September 2026: the assistant used to be a panel beside the page, raised with ⌘J (Ctrl+J) or a small ✦ capsule that floated in the corner of every page; documents and registers then carried a ✦ of their own in the row of controls above the page. The panel, the shortcut, the capsule and both record buttons are all gone, and the conversation has a screen of its own instead. The right-hand side of that screen belongs to the records the assistant changes — see Reading a record beside the conversation below.

Chat as a screen

The panel is the right shape for asking about the thing you are already looking at. When the conversation is the work, open Chat in the sidebar instead. It is the same assistant, the same conversations and the same starter prompts — given the whole page. Tables, comparisons and long drafts come back at full width rather than in a column beside your document, and the address bar holds the screen, so it survives a reload and can be bookmarked or opened in its own tab.

This is the only place the assistant lives now. Until September 2026 there was also a panel that opened beside whatever page you were on, raised with ⌘J or a floating button in the corner of the window, and each document and register carried a ✦ button of its own. All of them are gone: the sidebar's Chat entry is the way in, and it lands here. Your conversations are unchanged — everything you started in the old panel is in All chats where you left it.

It is about whatever you pin. Arriving from the sidebar it is the workspace conversation; the ⌖ picker in the composer pins or unpins the record it should be about. A conversation you started about a record earlier is still that record's own thread, in All chats.

Asking what a clause needs is worth a word, because it is the question a separate audit report used to answer. Ask it — “what do we need to do for clause 4.1?” — and the assistant reads the clause itself, what your own documents already say about it, and where you stand, then answers in words. Nothing is filed; it is a reading, so there is nothing to open afterwards.

Reading a record beside the conversation

When the assistant changes something, it names it — “added clause 4.3 to Access Control Policy” — and the name is a link. Click it and the record opens in a panel on the right of the conversation, so you can read what changed without losing your place in the thread. Documents, registers and risks all open this way; anything else the assistant names still opens as its own page.

What the panel shows:

A document — its text, as it is written now.
A register — the register itself, read-only: the same page a share link opens, with every column, the view's filters, sorts and groups, and a row you can expand to read in full.
A risk — the risk as its own page shows it, read-only: the description as it was written, the treatment actions, and the properties beside them — code, owner, created, type, status, severity with how it was derived, the due date and, for a finding an audit raised, where it came from.

Three things are worth knowing:

The panel only reads. Nothing in it can be edited, approved or published. When you want to change what you are reading, Open full page takes you to the record itself, where everything works as it always has.
It is part of the address. Open a preview and the address bar holds it, so a reload brings the same record back and a link you send to a colleague opens the conversation with that record already beside it.
It is yours to size. Drag the panel's left edge to give it more or less room; the width is remembered. Esc or the ✕ closes it. On a narrow window it covers the conversation instead of squeezing it.

If a record has been deleted, or belongs to a team you are not in, the panel says so rather than showing an empty page.

Talking about the document you have open

Open Chat in the sidebar and pin the document with the ⌖ picker in the composer. Documents and registers carried a ✦ Talk to Alchex about this document button in the row of controls above the page until September 2026; a record draws no button onto the assistant any more, and the pinned record does the same job from the conversation's own side.

Reading and talking at the same time still works, the other way round — the assistant names the records it changed, and those open in a read-only panel next to the conversation (above).

A chat opened from a record is about that record, and two things follow:

It resumes. The conversation is that document's own, not the general stream. Come back to the same document tomorrow and you are back in the thread you were in — what you asked, what it proposed, what you approved. Open a different document and you get that document's thread instead.
It is already focused. The document is pinned as soon as the screen opens, so what is missing here? means this document without you pinning anything. The pin is an ordinary focus chip: remove it with its × to widen the conversation, or add more records with the ⌖ picker.

New chat from there starts a new conversation about that same document, not a general one. Everything else — the cards, the queue, attachments, the allowance — is the same assistant, because it is the same assistant: arriving from a record scopes the conversation, it does not open a second one.

By default the conversation follows whatever you have open — the input shows Following your page. Focus the conversation pins it instead: pick specific records from Governance, Risks, Controls, Audits or Registers, or leave it on All documents, where retrieval decides what is relevant. Opening the picker lists your most recently updated records straight away, so you can browse and pick without knowing a title; typing filters them, and each tab shows how many matches it holds. Typing ignores accents and letter case, on every kind of record — erisim finds Erişim Kontrol Prosedürü, and a name written with a dotted İ is found by a keyboard that has no such key. What you type is matched literally otherwise: a % or an _ is the character you typed, not a wildcard. You can search by a record's code as well as its name. You only ever see records your teams can reach. The picker keeps a Controls tab of its own so a control is easy to pin by what it is — even though in the app a control lives in the Governance list like any other record. You can also pull a record straight into a message with @. Once you pin something the header reads Focused — not following your page, and Follow page instead returns it to normal.

Every kind of record can be pinned, not only documents. The picker searches the same kinds the rest of the app keeps — documents, risks, controls and registers — so a question like does this register still back the policy? can be asked with both records pinned at once. A pinned register is read by its rows, exactly as if you had asked for them by name. Pins survive a retirement: archive a register while a conversation is pinned to it and the chip keeps naming the record rather than quietly disappearing.

Answers carry a Grounded in footer listing the records they were built from. If an answer is wrong, just say so — "that's wrong", "that's not what I asked" — and it is recorded as feedback without you having to find a control (see Rating answers and data controls); Retry this message re-runs the same turn. Edit & resend from here rewinds — the banner warns that sending rewinds the chat from that point, and everything after that message, including anything the chat had remembered, is dropped.

There is a limit on how long one turn may run. A turn that reaches it — usually one asked to rewrite several documents at once — is stopped and says so plainly, rather than failing as though something had gone wrong. Nothing is changed when that happens, and asking for less in one go, a single document or a few sections, gets through.

It works to the rules for the kind of record you are on

The assistant does not carry one flat set of manners. What it is looking at decides which working rules it holds itself to, and the rules are the same ones a careful colleague would follow.

On a document it reads the document before proposing any change to it, never from memory or from an earlier look, and it copies your section headings exactly as you wrote them rather than a tidied-up version. If it cannot find a section that matches, it offers to add one instead of forcing the change into the nearest heading.
On a register record it works from the record you have open rather than searching for it again, and it treats the record as a case: before proposing how to handle it, it looks for the procedure of yours that governs it.
On a clause or a control it keeps requirements and recommendations visibly apart. What a standard requires is quoted as required; what a guide recommends is named as guidance, with the guide and section, so you are never told a recommendation is mandatory or a requirement is optional.

Underneath all of them sits one rule about honesty: it never tells you a change is done when it is only proposed. A change waiting on your Apply is described as proposed, a card waiting on your approval as waiting, and only something already applied is described in the past tense.

It follows your own procedures

Your procedures, policies and instructions are not only text the assistant can quote — they are the way your organization does things, and the assistant follows them. Bring it a problem — how do we create a new procedure?, what do we do with this finding?, this run failed, what now? — and before it improvises an answer it checks whether one of your documents already governs the case. When one does, it says which, and quotes the sentence: your Procedure Management Procedure §2 defines how a procedure is created — shall I follow it? Nothing happens until you say yes. Then it walks the steps as written, proposing each action as an ordinary change card and naming the sentence that authorizes it, exactly as it would for any other change.

It always reads the document as it is now. The assistant keeps only a list of your methods by name; the text is read at the moment a conversation needs it. Edit a procedure and the very next question that touches it is answered from the new wording — there is no copy anywhere to fall behind, nothing to sync, nothing to publish first.

A finding, a risk or a register row pinned in the conversation is treated as a case: the assistant looks up which of your procedures govern that kind of record and offers the governing one. The processes built from your procedures are part of the same picture: it can tell you what a procedure runs and when, whether a given process is switched on, and what its recent runs did — read from the runs' own receipts, never guessed. A process that starts on demand can be run from the chat once you confirm; a process can be switched on or off by asking; and the outcome you see is what the run reported — ran, waiting on a decider, or failed with the reason.

Say it in chat, and both halves arrive together. Ask for something new — remind document owners every quarter to review their documents — and the assistant proposes two things in one reply: the sentence, added to the procedure that owns the subject, and the process built from that sentence. A process is never created without the wording that authorizes it; if the wording has not landed by the time the build runs, nothing is switched on and the card says so. When no document governs the subject at all, it drafts a short procedure stating the rule first, and builds the process from that.

A document your teams cannot reach is simply not found — the assistant never confirms that it exists elsewhere.

The monthly AI allowance

AI work draws on your workspace's monthly allowance — one shared pool, not a per-person quota. Every AI surface counts against it: chat turns, the checks inside a procedure, drafting, and the checks that summarise a connected resource when you preview or re-check evidence.

The allowance resets each period, and the counter starts again from zero. While it is exhausted, AI pauses rather than failing oddly: you get a plain message saying the allowance has been reached, queued messages hold, and everything that is not AI keeps working normally. You can wait for the reset or raise your monthly volume, which applies immediately.

You are charged for what a request actually costs, recorded after it runs — a short chat turn costs a fraction of a procedure that checks many requirements. The allowance is checked before each request starts: with allowance left you are admitted, and at the cap you are refused with a message saying so. Work already running when the cap is crossed finishes and is billed for what it used, so the final figure can sit slightly past the cap. See how the allowance meters.

The Billing page shows what has been used this period, including a breakdown of each member's contribution. That breakdown is informational — the cap is always the shared workspace pool.

When an answer names one of your records — a document, a register, a risk, a control, a connector label — it appears as a small chip you can click to open the record. Registers are cited this way too: an answer built from reading a register names that register as a chip, not as loose prose. Pasting a record's own web address into the conversation renders the same chip, and the two behave identically: a record you may not see is shown as a restricted record rather than by name.

A record that has since been removed keeps its name and reads red, in an answer from months ago exactly as in a document. It used to be turned into a restricted record too — so a transcript written in March quietly changed its words in August, telling the reader they lacked permission when what had happened was that their own team retired the record. Only the team boundary produces the restricted wording now. See References. Links that are not records — another site, another workspace — stay ordinary links. Your own messages never show citation plumbing either: when you pull a record into a message with @, your bubble reads its name, not machine syntax.

When the assistant needs input it asks rather than guesses: the question renders as a card with its options listed — the recommended one marked Suggested — and you answer by typing your reply, in your own words or by naming an option. Answer as soon as the card is on screen: if the assistant is still finishing the sentence under it, your answer stops that sentence and goes through at once rather than waiting in the queue behind it. Recorded in this chat lists everything the conversation captured, and each line can be removed or forgotten.

What a conversation settles about your organisation, a team or you is written to the memory pages — the organisation's page, the team's page, your own — which the assistant reads at the start of every conversation so nothing established is asked twice. A disagreement never overwrites a page line; it is noted under Under review for someone who can edit the page. See Memory.

You can also tell it something without asking anything. A message that starts with # — #we are fully remote, no offices — is saved straight as a remembered fact rather than sent as a question, so no reply is generated and nothing is spent on it. A chip confirms what was saved and offers Undo; from the next message onward the assistant treats the fact as true.

A question about where you record something — where completed training is written down, where exceptions are logged — is still special, because a typed sentence is not really an answer to it: the honest answer names a register you keep. Reply with the register's name to bind it, ask the assistant to create the register, or say "decide later" to park it. See Templates and the marketplace.

You can Dictate a message instead of typing, Stop generating mid-answer, pin an important card with Pin to Decisions, and Share a read-only public link to the conversation.

Conversations save themselves. You never press anything to keep one: the moment you send a first message the chat is created, named from what you typed — or from the file's name if you only attached one — and it appears in All chats, where you can rename, pin, archive, or delete it. Archiving tidies rather than destroys: the list's Chats / Archived filter switches between your active chats and the archive, and an archived chat can be read again from there or put back with Restore — only delete removes a conversation for good. Because the exchange is stored as it happens rather than when you leave, you can close the panel mid-answer and come back to it, and the per-message actions that need a saved message — rating a reply, pinning a card to Decisions, or editing and resending from a point in the thread — are available on the reply you just received, not only on one you reopened later. A reply in progress also survives Alchex itself being updated: when a new version goes out while the assistant is mid-answer, the answer already running is allowed to finish rather than being cut short.

You never have to wait for a reply to keep going. Sending while the assistant is working adds the message to a Queued strip above the composer — each queued message runs automatically, in order, when the current reply finishes. A queued message is still a draft until it fires: click it to edit it in the composer, use the arrows to reorder, or × to remove it. Pressing Stop generating also pauses the queue — nothing fires until you press Resume — and Clear all empties it. The queue also pauses itself rather than failing through its remaining messages: after a failed turn it holds until you resume, and if the workspace's monthly AI allowance runs out the strip says so plainly — queued messages hold until the allowance is raised or resets. The queue lives in the current chat only; switching conversations discards it.

When a conversation is producing several documents, a Document builds rail appears above the composer listing every build and its state — Drafting…, Ready for review, Created, or Failed — so you don't have to scroll the transcript to check on each one. Review jumps to a build's card; a created document gets its Open document link right on the rail. Builds keep running while you are elsewhere in Alchex, and a finished build is on the rail when you come back to the conversation.

Where the numbers in a panel come from

When an answer arrives as a panel — a table of your documents, a breakdown by status — the figures in it are read from your workspace, not written out by the assistant. It names the records it wants shown and Alchex fills the rows from what it just looked up, so a value in a table is the value on the record. A long list is trimmed to keep the panel readable, and the last row says how many were left out rather than the table quietly ending.

Attachments

You can hand the assistant a file with the message. Use the paperclip in the composer, drag files onto it, or paste an image straight in. Photos (PNG, JPEG, GIF, WebP) and documents (PDF, Word, plain text, Markdown, CSV) are accepted — a photo of a whiteboard, a signed form, a supplier's report — and the assistant reads them as part of the question rather than as a separate step.

Attach up to four files per message, each photo up to 5 MB and each document up to 20 MB, and 25 MB across the message. Files upload as soon as you pick them, so each one shows as a chip with its name while it uploads; remove one with its ×. The message waits until every upload has finished.

Attachments are stored in your workspace, counted against your storage, and stay on the message — photos appear as thumbnails in the transcript and documents as chips you can open. Only people in your workspace can open them.

A shared conversation is the exception: a public link lists the file names only. The files themselves are never served from a share link.

Picking up where you left off

Say "let's continue" or "where were we?" and the assistant does not ask you what you were doing. It opens your task list — the same one on your compliance record — and starts at the cursor: the item that was being worked, and which step it had reached. Your position is on the record, so it survives the conversation ending, a week away, and a different person picking it up.

The same list answers two asks you might not think of as the same thing. "Find the weaknesses" works the clauses on it; "start the journey" works the documents on it. There is no second plan being kept somewhere.

As work moves, the assistant moves the cursor with it — so the next session starts where this one stopped. Tell it "not now" or "skip that" and it parks the item with your reason on it, and will not raise it again until you unpark it. What it will never do is tick something off for you: a clause is finished when its check passes and a document is finished when it exists, so the assistant can record a promise as kept, and nothing else.

Changes — what waits for you, what applies at once, and the receipt every one leaves

Your team decides how much the assistant may do without asking. Out of the box every change waits for you: when the assistant proposes one — logging a Register record, creating a register or adding rows to one, editing a document body, archiving, creating a document from a template or a whole set — you get one short line saying what it will do, and a second line inviting you to answer. Nothing has happened until you do. You answer in words — yes, go ahead, do it, or no — in the same box you say everything else in; there are no buttons on the card to hunt for. Once it runs, what you read is the receipt: a sentence saying what actually landed, written from the server's own answer, with a link to the record it touched.

You can widen that in the chat itself — see Permission mode below. In the widest setting a change runs as it arrives and the receipt is the first thing you see, with no button in between. To take one back, say so — "undo that" — and the assistant reverses it the same way it applied it: edits land only in the live draft (readers see nothing until you publish), register rows arrive as suggestions that count for nothing until a person confirms them, archiving is reversible, and every AI edit still leaves its margin comment and its place in version history.

The assistant can also offer work you did not ask for — the real register behind a placeholder name, an authored template that covers a gap it noticed. What that offer looks like follows what it costs: a template fill or a register costs nothing and lands as the offer itself, a draft you can dismiss; a document it would have to write from scratch spends your AI allowance, so it is offered in a sentence first and drafted only when you say yes.

Two kinds of work never run from chat at all. Anything that spends money on its own — running a procedure whose checks bill your workspace's AI allowance — and anything that leaves your draft: publishing a version to readers, or submitting a document to its approver. The assistant will tell you what a run found or what publishing would change, but the actions themselves stay where the rest of Alchex keeps them — Run now in the document's Workflow panel, publishing and submit-for-review from the document's own controls — so a billed or outward-facing step is always a step you take deliberately, on the record itself.

If a change cannot run, the card says why, in the words of the refusal — a role your team has not given you, a document frozen in review, a publish blocked by unanswered required inputs — and the way forward is the conversation: answer what is missing, or ask again once the state clears. A refusal is kept on the transcript exactly as it happened, so a reloaded conversation still says why nothing ran.

Writing a document from scratch takes the assistant a while, so the card shows its progress rather than a blank wait. The document's section headings appear within a second or so — the real ones it is about to fill — with a count of how long it has been drafting beside them, and Stop if you would rather not wait; stopping costs the draft and nothing else. Once the body arrives the draft saves itself and the receipt links the new document. The one draft that refuses to save on its own is one that contradicts itself — the same person approving their own requests, an approver the document never names: the card lists the problems under Resolve before drafting, saves nothing, and leaves the next move to you — ask for a revision, or tell it to save anyway. Inputs required before publish stays a checklist, not a barrier: the draft saves, and it is publishing that waits on those answers. A new document is filed in one of your teams; move it from the document's own page if it belongs elsewhere. When the assistant is writing into a document you already have open, the draft joins that document and keeps its team.

If the assistant describes a change but attaches no proposal, the chat calls it out and offers Produce the proposal — so a described change never gets mistaken for a made one.

One turn can carry more than one change, and each runs and receipts on its own — a failure in one never hides the ones that landed. Receipts survive a reload exactly as they happened; a proposal from a session that ended before it could run is shown as never completed, and asking again is the way to redo it — nothing re-runs on its own when a conversation reopens.

Permission mode

One setting says how much the assistant may do without waiting, and it lives in the chat, beside the message box — where you can see which one you are on while you work. It applies to the conversation you are in, so you can leave one chat cautious and let another run.

Ask — every change waits for your go-ahead.
Accept edits — edits to things that already exist apply straight away: changing a document's text or its details, adding a row to a register you keep, linking a record to a control. Anything new, and anything a person outside your team would see, still waits.
Full — everything the assistant proposes applies at once.

A new chat keeps the mode you last chose, so you set it once rather than every time you start a conversation. If you have never chosen, it is Ask. The control says when the mode was carried over rather than picked here.

You can set it before you say anything. Open a new chat, pick the setting, then type — your first message is already governed by it, and the control says Applies to this chat as soon as you send so you know it is your choice and not one carried over. If that choice cannot be saved, your message is not sent and the assistant says so: sending it under the previous setting could change things you meant to review first, and a message you send again costs less than a change you did not want.

It used to be a team setting, and that was the wrong home: a conversation belongs to no team, so the app took the most cautious setting across every team you were on. One team left on Ask governed your chats everywhere, nothing could tell you which team had decided, and the control sat on a page nobody working in the chat would open. One consequence is worth stating plainly rather than leaving you to find it — there is no longer an admin ceiling: anyone can put their own chat on Full. What that cannot do is widen anything else — the role gates on each record still refuse what you were never allowed to do, and the three rules below still hold.

Accepting a clause finding — telling the record this is fine, remember it — counts as new rather than an edit, so it waits under both Ask and Accept edits. It does not change a record; it changes how later checks judge, which is a larger thing to let through on its own.

Three things do not change whichever setting you pick.

Publishing, archiving, deleting, and sending a compliance reply never apply by themselves, in any setting — Full included. They wait for a person every time, because they are the changes someone else sees or cannot easily take back. Sending mail from your connected mailbox is the strongest of these: the assistant drafts the reply, and it leaves the mailbox only when you approve it.

Every change is recorded either way — what was proposed, who decided it, when, and whether it was applied, dismissed or refused. A change that applied by itself is recorded as exactly that.

You decide in words. A change that is waiting shows you what it will do and asks you to say so: yes, go ahead, do it. Saying no — "no, don't", "leave it" — ends it just as completely: nothing is written, nothing is undone, and the record says you declined it, so no card is left offering a change you already refused. A card that is waiting notices a decision you made anywhere else — in words, in another tab, or by a colleague who may decide it — and turns into the receipt for what actually happened, rather than sitting there asking about a change that has already landed. If what you are rejecting is the wording rather than the change, say that instead and you get a corrected one rather than nothing.

A document you are building with the assistant is the one exception, and it is not a gap. While a build is running, each section is written straight into the document and then offered to you as Keep it or Change something — the build's own question, asked about the same text the waiting card would otherwise have asked you about. Under Ask the two would ask you twice about one section, and the first would stop the second: nothing could be written, so nothing could be kept. So a section of a document still being built does not wait for your go-ahead; you approve it by keeping it. The moment the build is finished the document is an ordinary one, and its edits wait for your go-ahead like any other. Nothing else about a build is exempt — creating it, archiving it and publishing it all follow the setting.

The gate is the setting, not the wording. The assistant is told which setting your team is on so its sentences match what is about to happen, but the setting is enforced where the change is made, not by the assistant remembering to ask. If it ever proposes something your setting holds, the change still waits.

It will not tell you something landed while it is still waiting for you. Because you decide in words, the assistant is also the thing you decide to — so a reply that says a document "has been added to your library" when the card is still waiting sends you looking for a record that does not exist yet. It now says which of the two happened: made when your setting applies the change at once, and waiting for your go-ahead when it does not. If you ever cannot find a record it mentioned, the change is almost certainly still on its card.

It will not ask twice for the same change. The assistant can see what this conversation is already waiting on, so telling it yes or try again releases the change already on screen rather than proposing a second copy of it beside the first. Asking for the same thing again does not queue up duplicates.

Changing the setting affects what happens next; a change already waiting stays waiting until someone decides it.

Changing one part of a control's plan

When the document you are working on is a control written as a numbered plan, you can ask for one part of it to change — "break-glass reviews should be within 1 business day, not 2", "an unreviewed use should be a serious gap" — and the reply is a card about that one part rather than a rewritten section.

The card names what it is changing (Benchmark · Break-glass review window) and shows the change itself: the current wording struck through, the new wording beside it. Six kinds of change can be proposed this way — adding a check, changing one of a check's fields, removing a check, setting a benchmark, changing a scope line, and naming a source on the evidence list. A check edit is per field, so changing a verdict shows one line and leaves the rest of the check alone.

The change lands in the draft, and only in the draft. Publishing stays exactly what it is elsewhere in Alchex — a separate, deliberate step you take from the control's page — so a proposed change never reaches the definition an audit reads until you publish it. If you have the control open in the editor, the change appears there as it lands, the same way a colleague's edit would.

If somebody edited the control between the proposal and its arrival, the change does not apply anyway. The card says the part has changed and shows what the control says now — reply and the assistant re-reads the control and proposes against the current wording, rather than writing an old proposal over new work.

Controls written before plans existed — a paragraph of instructions rather than numbered checks — have no such parts to name. There, the assistant falls back to an ordinary document edit and tells you why, instead of pretending to address a structure the control does not have. See What a new control starts with.

Registers the assistant keeps for you

The assistant can read your registers to answer a question about them, create a new one when a document cites a log you do not keep, and add entries to a register you already have. Both writes hold to the same two rules: it may only propose a row it can quote a real source for, and a row it writes lands as a suggestion that counts for nothing until a person confirms it — so a register the assistant filled proves nothing until you have stood behind its rows. Full behaviour is in Registers.

It comments on what it changed

Every edit you approve leaves a note in the document's margin, on the section it changed, saying what it did and why — attributed to Alchex, in the same comment threads your colleagues use, so you can reply to it or disagree with it. See Comments.

Which parts it can change

The assistant addresses a document by its parts — the individual paragraphs, tables and headings it is made of — not by hunting for a heading title. Three things follow, and all three used to be limitations you could run into:

A document with no headings can still be edited. So can the opening paragraphs that sit above the first heading. Previously the assistant could only add to the very start or the very end of such a document, because a heading was the only thing it could aim at.
Two sections with the same title are told apart. Scope, Responsibilities and Records repeat in most well-written documents. The assistant now changes the one you meant, instead of reporting that the title is ambiguous and asking you to rename one of your headings to suit it.
It changes the smallest part it needs to. Asked to fix one sentence, it proposes a change to that paragraph rather than rewriting the section around it. This is the difference you feel in the next section: a narrow change collides with a colleague far less often, so far fewer proposals get held back.

You never see or type a part's identity — it is internal, and it stays with the paragraph even when you reword the heading above it.

What its writing looks like

The assistant writes in ordinary formatting: headings, bold, lists, and tables. A procedure's steps come back as a numbered list, and objectives with their targets as a bullet list with the target indented beneath each one — the same things you would type yourself, and editable in exactly the same way.

Documents written before this change may contain older step and objective blocks. They keep working and keep their wording; the assistant reads them, and any part of one it rewrites comes back as an ordinary list.

It writes in your language. Pick a language under Settings → Profile and everything the assistant writes for you follows it — chat answers, drafted documents and reviews, audit findings and their reasoning, coverage checks, corrective-action drafts, control plans and the plans it builds from a procedure. The choice is saved to your account, so a new device or browser starts in your language the moment you sign in. Names of standards, clause numbers, record keys and the names of your connected systems stay as they are, and a quote the assistant takes from one of your documents stays in the language that document is written in.

Work the assistant does for the whole workspace while nobody is signed in — a corrective action drafted overnight — has no person to follow, so it follows the workspace language an admin sets under Settings → General; until one is chosen it writes in English. A tidied memory page is the one exception: it keeps the language the page itself is written in. See Workspaces.

Your references come back too. A chip pointing at a document, control, risk, register or connected source reaches the assistant as an address it can carry through a rewrite, so a rewritten paragraph still cites what it cited before. The one place to know about is a chip inside a table cell: the assistant still reads it and still writes it back, but a requirement check does not currently count it when it goes looking for the evidence a document cites. If a claim rests on a citation you want a check to see, keep that citation in the prose rather than only in a table. See References.

When you and the assistant change the same part

The assistant works from the document as it stood when you asked. If you edit a part in the meantime and its answer rewrites that same part, Alchex will not merge the two and will not overwrite you. Your words stay in the document, and the assistant's version is held to one side as a proposal for you to decide on.

This holding rule exists for the assistant alone, because it writes whole parts from a snapshot that may be minutes old. People are never held back by it: your own edits and your colleagues' always land in the draft directly — see Collaboration.

You will not lose it, and you will not have it applied behind your back. Held proposals collect on the document's Assistant proposals panel, opened from the same group of buttons in the top bar as comments and version history. Its button is a pen over a page — it wore a sparkle until August 2026, when the assistant's own button in that bar took the symbol, and that button has since gone too — and it appears only when something is actually waiting, with a small dot beside it — and because that button goes away once you have decided the last card, the panel carries its own ✕ so you are never left inside a panel whose only exit has vanished.

Each proposal shows three things:

which part it is for — the part's own current wording, so you recognise it by reading rather than by hunting. Show in document scrolls the body to it;
what is proposed — whether it is a rewrite, an addition, a removal, a move or a wording change, and the words it would put there;
how far behind it is — Written before 3 later changes, so you can tell a proposal written a moment ago from one written before an afternoon of editing.

Apply puts the proposal into the document the ordinary way, exactly as if it had been written now. Dismiss records the decision and changes nothing. Everything else that could happen is said plainly rather than smoothed over:

What happened	What the panel says
Several proposals landed on the same part	They stack under that part, oldest to newest. Deciding one leaves the others waiting
You deleted the part in the meantime	That part is no longer in the document. Apply is switched off; Dismiss still works
Somebody decided it in another tab	That one had already been decided somewhere else — a second click is a second click, not an error
The part changed again while you were deciding	That part changed again while you were deciding, so the proposal is waiting once more. The text did not land, and the same question is asked again
The change could not be read back	This change could not be read back, so nothing was applied. Ask for it again — nothing was changed. Said in those words rather than as a fault in the change you approved, because nothing about it was wrong

A proposal is not part of the draft until you apply it, so publishing never carries an undecided one into the version your readers see — see Publishing.

A pending review does not stop any of this. Applying an assistant's edit while an approver is deciding is allowed, and it does not change what they are deciding on — that is a fixed copy taken when the document was submitted. The applied edit rides the next version. See Submit and approve.

Anyone who can read the document can read what is proposed. Deciding needs permission to change the document, the same as writing in it does.

This only applies to a part that changed under the assistant's feet. An answer that rewrites a part nobody has touched simply lands, and turning every assistant edit into something to click would make it useless to be right about nothing.

Proving a document meets a clause

There is no longer a separate document audit. A document is checked by the procedure that governs it: place Check a requirement steps in that procedure, say which clause each one answers for, and run it. The verdict lands on the run's receipt and updates where you stand on that clause — the same number the Compliance page shows. See Workflows in documents.

Two things moved with it, and it is worth knowing where they went:

Asking what a clause needs. Ask the assistant — "what do we need to do for clause 4.1?", "why is 4.1 not passing?" It reads the clause itself, what your own documents already say, and what the last check found on that clause — the check's own words, the requirement it judged and anything it quoted — and answers from them rather than forming a second opinion of its own. If no check has run on the clause, it says so, which is not the same as saying the clause failed. That is what the separate report was for.
Checking a clause again. Once you have fixed what the finding named, ask the assistant to re-check the clause. It offers first and runs on your yes, then tells you what changed. It re-runs the procedure whose check last moved that clause, with your own authority and the ordinary receipts — the same run you could start yourself from the procedure. A clause no procedure has ever checked cannot be re-checked: the assistant says so and names the clause, so you can add a Check a requirement step for it.
Raising a finding. A non-conformity is created on the record it concerns, like any other. See Risk records.

Non-conformities raised by the old audit are unaffected — they keep their name, severity, status and corrective-action history. What they no longer carry is a link back to the report that raised them, because those reports are gone. Their document and clause are still recorded, so the row still says what it was raised against.

Controls and evidence — per-control audit agents and the evidence they grade.
Workflows in documents — how a procedure checks a requirement and proves a clause.
Creating documents — templates and generated drafts.
Submit and approve — what happens after the assistant submits a draft.
Seats and licences — chat turns and requirement checks bill the actual cost of each run against the workspace's AI allowance.