AI review and assistance

Alchex's AI works from your own records — documents, registers, risks — 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. There is no menu of things to ask and no list to work through — a fresh chat is the question box, and you type the question. What is still owed on your framework is not lost by that: the assistant reads it before it answers, and it is listed on the compliance record (Saying no to something your framework asks for, below).

What you see while it works is a short list of steps in plain words (Checking your documents, Asking you), and then its answer. Its own working notes ("let me read the workspace first") are not shown, and neither are the names of the tools it calls.

To ask about a particular record, type @ in the box and pick it by name. The conversation is then about that document, register or risk 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 the window is now a panel you can put a record — or your chat list — into from anywhere in Alchex; see Reading something beside what you are doing 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 and the same conversations — 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; typing @ and picking a record pins it, and its chip's × unpins it. A conversation you started about a record earlier is still that record's own thread, in All chats.

What is still open is waiting on the landing screen. A fresh chat opens with the decisions you have not settled yet — one line per document, with how many are still open inside it. Tapping one starts the conversation on that document: the assistant arrives already holding the outstanding decisions rather than asking you which document you meant, and works through them one at a time. Answer each in the chat and the document is written as you go, so the count on that line falls and the line disappears once nothing is left open in it.

Every conversation has an address of its own. Open one from All chats and the address bar names it, so a reload brings that conversation back and a bookmark returns to it. A new conversation gains its address the moment it is saved — with the first reply — and your browser's Back button steps back through the conversations you opened, the way it steps back through pages. Conversations open for their members: a chat you started opens for you, and a session run by a document's agent opens for everyone on the document's team. A link handed to someone who is not a member shows them that the chat is not available rather than your thread.

Your team's agent sessions are in the rail. Above the recent chats, Sessions lists every session an agent has run on a document of a team you are in — newest first, each under one plain line of where it is, the same line the control's page shows. Open one and it is a conversation like any other, about the document the agent followed, with the composer at the bottom. A session cannot be pinned, renamed, archived or deleted; the document owns it. Opening a run from a control's page brings you here, to the same conversation — there is no popup.

A link can outlive its chat. Open the address of a conversation that has since been deleted, or one somebody else started, and the screen says so — This chat no longer exists — with a Start a new chat button, rather than an empty conversation that would quietly start a new one on the old address.

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 something beside what you are doing

The right-hand side of the window is a panel you can put things in, so you can read one thing without losing the other.

From 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 the panel, so you can read what changed without losing your place in the thread.

From a list. Every record list — your documents and registers under Governance, your risks, the list of approvals you have sent under My work — carries a small panel button at the end of each row. It opens that record beside the list, so you can read one, then the next, without going back and forth. The row itself is unchanged: clicking it still opens the record's own page, and ⌘/Ctrl-click still opens it in a new tab.

From My work. Each row under Waiting on you has a Review button instead. It opens the record beside the queue with what the review would change marked: a document shows the submitted version against the published one, and a register or a risk lists its changes above the record. The decision buttons stay on the row.

What the panel can show:

• A document — its text, as it is written now, under its code and version. An archived document says so; a live one carries no status tag, the same as the list.
• 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.
• All chats — your conversations, newest first with pinned ones on top. The list holds your 200 most recent conversations in each view — your pinned ones always among them — and searching looks through those; an older conversation is still there, and still opens from its own link. All chats on the chat screen opens the list here rather than replacing the conversation you are reading, so you can look through what you have and pick one without losing the thread you are in. Picking one opens it beside the list, and everything you do to a conversation happens here too: search it, start a new one, and on any row rename, pin, archive or delete. One filter above the list answers both questions you ask of it — All, Sessions, Chats and Archived — so your team's agent sessions and your archive are a single click away rather than behind a second switch. Deleting or archiving the conversation you are currently reading simply lets it go: the list stays open and the thread returns to a fresh chat.

Those are the record types that have a read-only view. Anything else Alchex can link to — a collection, a connected system — opens as its own page, because those are ways into a list rather than records of their own.

Things worth knowing:

• The panel only reads. Nothing in it can be edited, approved or published, and the chat list can only open a chat. 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 the panel and the address bar holds it, so a reload brings the same thing back and a link you send to a colleague opens the page with it already beside them.
• A record belongs to where you opened it. Leave for another part of Alchex and a previewed record closes behind you, rather than following you onto a page that never opened it. Your browser's Back button returns you to it. The chat list is the exception: it is how you move between conversations, so it stays with you as you do.
• 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 page 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.

It reads the library, not every copy

When you ask about your documents — what do we have, what still needs deciding, how many are ready — the assistant reads the same library Governance shows: the documents that are live. A document you archived has left that library, so it is not counted, listed or used to ground an answer. The assistant uses the list's own words for a document — Active or Archived — and only mentions whether a version has been published when you ask about publishing. If some were set aside, the assistant may say how many, but it does not read them unless you ask about an archived document by name.

Two things follow from that. A count in chat matches your Governance list for documents; registers are their own record kind, so a Governance page that lists both will show more rows than a list of documents alone. And when the assistant opens a document it has been given the id of, it is told plainly whether that document is live, archived, or an unsaved draft — so an old copy is never mistaken for the one you keep, and it will not ask you to decide anything inside a document you no longer have.

Talking about the document you have open

Open Chat in the sidebar and pin the document by typing @ and picking it by name. 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 by typing @.

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, 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 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, each by its own name. 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.

When you ask whether something is required

Tailoring a document means deciding things, and the question behind half of them is the same one: do we actually have to?

The assistant answers that from the clause, not from memory: whether the standard requires the outcome, expects it, or leaves it to you, and which clause says so.

Two things it will not do:

• State that something is required, optional, or fine to skip without saying where that comes from. It reads the clause and answers from the text — and where the text does not settle it, it says so rather than producing a verdict.
• Change its answer because you disagreed. Push back and it re-reads and answers from the text again. It may agree with you, disagree, or say you are each half right — but a reversal comes with a clause, not with an apology.

Both are enforced rather than intended: a reply that reaches an obligation with no clause behind it is sent back to read one before it goes out. When you ask whether something is required is the whole story — the difference between having to do something and having to write it down, and what happens when you tell the assistant it is wrong.

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 quotes the exact words it is changing. If those words are no longer there, because someone changed them in the meantime, it reads the document again rather than guessing.
• 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 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 when you have said so. That choice is yours and is kept in the workspace notebook: tell the assistant follow our Procedure Management Procedure when you create a document, and it remembers. From then on it walks that procedure's steps as written, naming the sentence that authorizes each action. Without such a choice it never stops to ask whether to follow a procedure — it does the work you asked for. Ask how do we create a new procedure here? and it answers from your own documents.

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 follows the procedure your notebook names for that kind of record. A document's schedules and controls are part of the same picture: it can tell you what a document is asked and when, whether a control is switched on, and what its recent runs did — read from the runs' own records, never guessed. A control can be run now, switched on or off, or given new words and a new clock by asking, and the outcome you see is what the run reported — ran, waiting on a decider, or failed with the reason. Asking it to set up a control the document already has changes nothing: it tells you the control is there and offers to change or run it instead.

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

When you have no procedure of your own, it brings ours. Alchex ships built-in guidance for the management processes your framework asks for — incident handling, supplier management, internal audit, risk, access, change, continuity, and the rest — each written against the clauses it satisfies. Ask how should we handle incidents? in a workspace with no incident procedure and the assistant answers from that guidance, names the clause of your framework behind each step, and says it is our guidance rather than your rule. It creates nothing you did not ask for (a document comes only from the design conversation above, and edits are ordinary change cards), and the moment you publish a procedure of your own for the subject, yours is the one it follows.

A check it runs for a control is judged by the same guidance. When a control runs on its schedule, the session carries the built-in guidance for the topics its requirements cover, so what counts as "met" for a requirement is the guidance's reading of it, the same every run, and never the assistant's memory.

It uses the same tools your workspace has. Beside reading your documents and registers, the assistant can reach every system connected under Connections — the issue trackers, code hosts, chat, mail, drives and directories your workspace has authorised — and read from them in the conversation: which open tickets mention this policy?, is there a retention schedule in the drive?. It reads only; it does not create or change anything in a connected system. Each of those reads runs as you, with your teams and your role, so it can never see in a connected system what you could not see yourself, and every call is listed in the answer's working ledger. A system that is not connected is simply absent from what it can do — connect it and the next message can use it.

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 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 message 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. Remembered, in the bar under the conversation, lists everything the chat captured, and each line can be removed or forgotten.

Within one conversation the assistant also keeps what it has already looked up: what a check, a search or a record read came back with. So it does not run the same check twice, and it does not offer something it has just found cannot be done.

When you answer one of its questions, your answer is kept with that question, and the assistant will not ask it again, in this conversation or a later one. To change an answer, just tell it the new one.

It reads an uploaded PDF the same way it reads any other document, from the text in the file.

When you answer while a document is open beside the chat, your answer is also kept with that document — any document, whether it was built from a template, written from scratch or uploaded. Anyone's assistant that opens the document later sees what you said, so it does not ask again; if the document's text says something different, the text is what counts.

There is no separate memory to keep up: what the assistant knows about your organisation is what your documents say, read when it needs them. Something lasting about the company or a team belongs in a document. A message that starts with # is sent like any other. See Memory.

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 and the document cites it, ask the assistant to create the register, or say "decide later" to park it. See Registers.

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 filter switches to Archived, and an archived chat can be read again from there or put back with Restore — only delete removes a conversation for good. 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.

A reply carries on without you

A turn belongs to the conversation, not to the tab you asked it in. Once you have sent a message the assistant keeps working on our side, and what it produces is written into the conversation when it finishes — whether or not you are still looking. So you can ask for a long draft, open another page, close the tab or switch to your phone, and nothing stops: the reply is in the conversation when you come back. That holds even if you leave in the same instant you press send — the message still reaches the assistant, and the turn starts without you. It holds for the changes the assistant makes, too: an edit it proposes to a document is applied whether or not you are watching, exactly once, and when you come back the card under the reply shows what landed, with its link. Open the conversation while the assistant is still working and you rejoin it mid-answer, with your own message at the top and the reply arriving as it is written, exactly as if you had never left. A brief network or server hiccup while you watch does not end it either: the screen keeps following the turn and the reply still arrives. Stop generating is the only thing that ends a turn early, and even then what had been written so far stays in the conversation.

If the assistant is still working when you open a conversation from All chats — or from the link in your address bar on another device — the reply picks up where it is, not from the beginning, and nothing is asked twice.

A conversation can also be one of a document's agent sessions — a scheduled run the agent could not finish without you, stopped on a question. Replying there is an ordinary message, and it is the answer: the run picks up from your reply and carries on, and what it does next appears in the same session. See Workflows. A conversation with more than one person in it (see People) works the same way for all of them, with two rules. You can see a colleague writing before their message lands — Ayşe is typing… above the message box — and Edit & resend from here is offered on your own messages only, because resending from a message discards everything after it, theirs included. A colleague's question is not shown on your screen while it is being answered: their message, under their name like every message in the thread, and the assistant's answer appear once the answer is saved, the next time you open the conversation. Anything you send while your own question is being answered waits in your queue and goes when the answer lands.

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.

Asking for a document

Tell the assistant what you want to put in place — we want to implement cryptography — and it designs it with you, then creates the document in your team.

It asks about how you work, never about the document. Each topic has its own short set of questions: where you use encryption, who looks after the keys, what happens if the one person holding a key leaves. It asks one at a time and skips anything your workspace or an earlier answer already says. Your answers are kept, so you are never asked the same thing twice, in this conversation or the next.

On each choice it gives you its view in three parts: what your framework requires, with the clause; what is left to you, with the default it recommends; and the risk of the choice you are making. A choice with a real risk — a key only one person can recover — is named as one, with the clause behind it. The choice stays yours.

Then it creates the document. When the questions are answered, or you say to use its recommendations for the rest, it creates the policy or procedure in your team and opens it beside the conversation. If you belong to one team it goes there; if you belong to several, it asks which once. The reply names the document and the team, so you always know where it is — it is in Governance like any other document from that moment, on the same lifecycle. The assistant writes it from how that process works, in its type's one standard structure.

Anything it filled in for you is marked. Every choice the conversation did not settle uses the recommended default, marked (recommended default) in the rule it sets, so nothing of ours reads as your decision. Confirm or change them before you send it for approval.

Change an answer later, and the document follows. Tell the assistant a choice has changed and it proposes the edit to the documents that use it, without touching sections you have written yourself.

A Reader cannot create documents, so the assistant never offers to for one.

Once a document exists it is fully the assistant's business again: it reads it, answers questions about it, and proposes edits to its text.

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 reads each standard's score — the controls passing out of the controls counted, the same number the Compliance page shows — and starts at the first control that is not passing, worst first: one whose last run failed, then one that couldn't run, then one whose last pass is past its due date, then one that has never run. Your position is on the record, so it survives the conversation ending, a week away, and a different person picking it up.

What it will never do is tick something off for you: a control passes only when its latest run passed, so the way forward is to run it, not to mark it done. "Find the weaknesses" reads the same list; there is no second plan being kept somewhere.

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

The assistant writes like a colleague. Ask it to change something — log a record, add a row to a register, edit a document's text or its details, draft a document beside the conversation — and it does, there and then, under your own account and through the same doors your own typing goes through. 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 are not asked to press anything, because you already asked.

That is safe for the same reason a colleague's edit is: you can see it, you can see it was yours, and you can take it back. Edits land only in the live draft, so readers see nothing until you publish. Every change appears in the record's own version history, attributed to the session that made it, and reverts in one click from there. Every AI edit also leaves its margin comment. And you can simply say so — "undo that" — and the assistant reverses it the way it applied it.

What still waits, and it is a short list: what a person must decide below. Nothing about it is a setting.

It never makes a record you did not ask for. If your answer names a register you do not have — an incident log, a risk matrix, an asset list — it says so in passing and carries on with what you were doing. Creating it is a separate sentence from you: "go ahead", "set it up". Until September 2026 it worked the other way round, creating the register as its way of offering one, on the reasoning that you could always delete it; that produced registers nobody wanted in workspaces nobody had asked, and it is gone. A document is never handed over as a filled copy to correct either: the assistant designs it with you in the conversation and then creates it, with every default it chose marked in the rule it sets — see Documents the assistant writes.

Publishing is not the assistant's. Say a document is ready — "publish it", "make it official" — and the assistant tells you to publish it from the document's page, where an owner of the document's team reads the change summary and presses Publish. A Writer is told an Owner has to. It could publish on your word from September 2026; on 2026-10-31 publishing left the chat, so the step that puts a version in front of readers is always taken by a person on the document itself.

Sending a document to its approver is something it can do. It was held back until 2026-09-10, and for a good reason while the platform owned the gate — it is an outward-facing step. But the approval module is the gate now, and a procedure that says a step needs someone's approval cannot be obeyed if the assistant has no way to ask for one. So it can send a document for approval, and that is the most cautious thing it can do with one: nothing publishes, and the request sits in My Approvals until someone decides. It sends the request to one named person — say who, or say "send it to me" and it is yours to decide; name nobody and it assumes you. If several people could decide it and you have not said which, it asks, and it never guesses between two colleagues with similar names. It will say the document is waiting, and who is holding it. And while that request is open, nobody can publish the document out from under it: a pending review refuses a direct publish.

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 document still missing 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.

And the reply says what really happened. Each change is made the moment the assistant decides on it, before it writes another word, so its sentence is about the result, not a guess: done, waiting for your word, or not made, with the reason. If Alchex could not confirm a change was saved — a rare break between our own services — the assistant says exactly that and asks you to check before asking again, and it never tries the change a second time behind your back.

Asked for a document you do not have, the assistant designs it with you and creates it in your team — see Asking for a document above — then writes it with you beside the conversation. When it is writing into a document you already have open, its changes go into that document's live draft and readers see nothing until you publish.

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. So does a change that is still waiting for you: reopen the conversation tomorrow, or from another tab, and the card is still there asking for your word — and if you already answered it elsewhere, it shows what became of it. A shared conversation marks such a card Waiting for approval. Only a proposal that never reached the point of asking — a session that ended mid-turn — is shown as never completed, and asking again is the way to redo it; nothing re-runs on its own when a conversation reopens.

Your yes does not have to stand alone. "Yes, but which team does it go to?" applies the waiting change and then answers the question; if the assistant ever answers the question and leaves the change waiting, it is sent back to decide it before you read the reply. And while a change is waiting, the assistant will say so — it never tells you a risk is in your register, or a document in your library, until it is.

What the assistant does on its own

It does the work, and tells you what it did. Ask for a section rewritten, a risk logged, a review date moved — and it happens, there and then, under your own account and through the same doors your own typing goes through. You are not asked to press anything first, because you already asked. What you read is the receipt: a sentence saying what actually landed, with a link to the record it touched.

Three things still wait for your word, and they are listed in the next section. Everything else is an ordinary change with your revision history behind it.

There is no setting for this, and there is nothing to choose. A chat carried an Ask / Full switch between September 12th and September 20th 2026, and it is gone. On Full the assistant created records nobody had asked for; on Ask it asked about every single change, including the ones you had just requested in the same sentence. Neither end was what anyone wanted, and the switch could not fix either — the unwanted records came from the assistant volunteering them, and that is fixed where it was caused: it never creates a register, a log or a sheet you did not ask for in words. If it needs one you do not have, it says so in passing and carries on.

Reading is never held. The assistant looks things up freely, in your workspace and in the systems you have connected.

What waits for a person, and what does not

Three actions always need your word. Your own written procedure is the other rule, and it is the one that matters most. And any connected app you choose Ask for waits too — see below.

Archiving a document, sending a version to a workspace that subscribes to yours, and sending a compliance reply never apply by themselves. This has never depended on a setting — they waited on the widest setting there ever was, and they wait now that there is none, because they are the changes you 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.

One sentence can ask for both kinds, and then you get both answers — not one question. "Fix this one and archive the other two" is two different things: the edit happens and the archives wait, so the reply tells you what it did and what it is holding, separately. It will not ask you to confirm something it has already done. If it ever does, that is a defect and worth reporting.

A connected app you chose Ask for waits as well. Each connection has one choice — Auto or Ask (Connections). On Auto the assistant uses the app directly. On Ask, every time it wants to use that app in your conversation it shows you what it wants to do there on a card and waits; press Apply and it does it, as you, and tells you what came back. Nothing else changes with that choice.

Publishing is not on this list because the assistant cannot do it at all. It left this list in September 2026 as an ordinary change, and left the chat entirely on 2026-10-31: an Owner publishes from the document's page.

It does not matter how the assistant reaches the action. As well as proposing changes in the conversation, the assistant can use the same tools your procedures' steps use — the ones that read your connected systems and work with your records directly. Those reach your connected apps and no one else's: the assistant is offered the connections you added, reads them as you, and asks you to connect an app you have not, rather than borrowing a colleague's sign-in. Archiving waits for you through them too: ask it to archive something and it comes back as a change waiting for your word, not as something already done, whichever route it took to get there. Restoring is the opposite case and is not held: putting a record back on your active lists is the undo, so it happens when you ask for it.

You decide those with the card's buttons. A change that is waiting shows you what it would do on a card with Apply and Dismiss, and nothing happens until you press one. Typing yes or go ahead does not apply it: the assistant points you to the card instead, because only the card's answer is tied to the exact change it asked about — the assistant cannot press it for you, and an answer for a different change, or the same answer sent twice, is refused. Apply carries the change out, as you, and the assistant tells you what happened. Dismiss ends it just as completely: nothing is written, and the assistant takes your no. A card you answered stays answered when you come back to the conversation. A change that waited for a typed yes before October 2026 cannot be released any more — ask for it again and its new card asks you.

Your procedure is the other rule, and it is the one that matters. When a document says a step needs someone's approval — "the retention schedule needs the Security Manager's approval" — the assistant reads that sentence and files the request through approvals, the same door you already use. It lands in My Approvals, addressed to the person the sentence names when it can identify them, and nothing publishes until they grant it. The work waits there, not in the chat, and the decision is recorded in the approval ledger like any other.

Nothing about that is configured. Write the requirement into the procedure and the next run follows it; take it out and it stops. There is no list of gated actions to maintain in settings, and no ceiling an administrator sets on your behalf — the role gates on each record still refuse what you were never allowed to do, and everything above still holds.

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

One kind of work still never runs from chat at all: anything that spends money on its own. That stays on the record itself.

It will not tell you something landed when it has not. The assistant says which of the two happened — made, or waiting for a person — so a reply never sends you looking for a record that does not exist yet. And where it says made about a change the app then refuses, the card underneath takes the sentence back rather than leaving it standing.

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 the assistant makes is a line on the document's history, attributed to Alchex, with the reason it gave.

Which parts it can change

The assistant changes a document the way you would describe a change to a colleague: these words become those words. Three things follow:

• It changes the smallest part it needs to. Asked to fix one sentence, it changes that sentence. Every other paragraph, table and comment stays exactly as it was, so a narrow change collides with a colleague far less often and far fewer changes are held back.
• Any document can be edited, with or without headings, and two sections with the same title are never confused, because the change is aimed at words, not at a heading.
• An empty document can be written in one go. The first text goes at the end, and so can a whole new section.

The only thing it cannot change this way is a picture, which you change in the editor.

Which clauses a document covers is set on the document, from its Scope picker, or by the controls set up on it. Editing a document's text does not change its links.

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 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. See Workspaces.

Your references come back too. A chip pointing at a document, 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:

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.

Saying no to something your framework asks for

"We don't have one" and "skip that" are ordinary answers. The assistant reads the clause behind the choice and tells you plainly whether skipping it leaves a gap, naming the clause — it never decides that from memory, and it does not change its answer because you disagree. When something is still owed, it can note it on the list of things you owe, so you meet it again in the session opening and in the answer to "what's next?". Say "stop asking about that" and it will not raise it again.

(Until 2026-10-12 each template decision carried an authored label — required, suggested, your choice — and declining one raised an item automatically. Those labels rode the template catalog, which is retired. Items raised that way before then still show, with their clause.)

Proving a document meets a clause

There is no longer a separate document audit. A document is checked by a control set up on it: each time the control runs, it records passed, failed or couldn't run for every requirement it proves, and that updates where you stand on the 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. A clause is checked by the controls that prove it, each on its own clock. Ask the assistant to check a clause — "check 9.2" — and it reads the attached documents against the clause and tells you what they cover and what looks missing, as its reading; if no control checks the clause yet, it offers to set one up.
• 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.

Related

• Controls — a control is a document of type Control.
• Workflows in documents — how a control 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.