One AI toolkit forsolution architects
Long specs read in one pass. Decisions written down while they are still fresh, in Confluence, without overwriting anyone. Technical tickets opened from your own notes. One menu-bar app, one shortcut, on macOS and Windows.
The decision took ten minutes,
writing it down took the afternoon
An architect’s day is reading things other people wrote, deciding between two uncomfortable options, and then leaving a trace that survives you. The deciding is the short part.
So the record gets thin. The decision lives in a call, then in four lines in your notes, then in a Slack message, and the decision log in Confluence is three weeks behind. Six months later somebody asks why the integration is asynchronous and nobody can reconstruct the trade-off. Khint attacks the two ends of that: reading, by letting an agent take a whole document as its input, and writing, by putting the tools you record in behind the same keyboard shortcut you use for everything else. Between the two, Memory keeps the thread of the project so you are not the only copy of it.
What an architect reads
A vendor's integration spec, as a PDF nobody will read end to end.
A slide deck from the platform team, and a spreadsheet of interface fields.
A screen share with the one diagram that is not in any document.
What Khint can take as input
PDF, Word, PowerPoint, Excel, OpenDocument, EPUB, RTF, text and code files.
Images, read with the same extraction as a screen capture.
Or just the text you have selected, in whatever app you are in.
One integration day,
spec to decision record
Every step below is a shipped feature, not a roadmap slide.
- 09:00Open a session for the integration, not for the dayStart a Memory session called 'Payments provider integration'. From here on, every document you read, every capture you take and every ticket you open is folded into a short working state: the objective, the open threads, the decisions already made. Later agents see that state, so you stop re-explaining the project to your own tools.
- 09:20Read the vendor spec without reading all of it firstPoint an agent at the PDF instead of at selected text: 'list the integration constraints, the required fields and everything this document leaves undefined'. You get the constraints and the open questions in one pass, and you go into the 10:00 call with a question list rather than a vague unease about page 34.
- 10:30Their screen share has the sequence diagram you cannot copyCapture the region and ask about it directly: which call carries the idempotency key, what happens on the retry path. It is a conversation about the screenshot, not a single extraction, and when it has told you something worth keeping you save the exchange into the session. For the error code table on the next slide, plain text extraction puts it on your clipboard.
- 11:30The decision gets made, so it gets recordedSelect the four scrappy lines you wrote during the call, run your decision record agent, and it comes back in the shape your team reads: context, options considered, decision, consequences. Then append it to the Confluence decision log. The existing page is copied through untouched and your entry lands at the end.
- 14:00Turn the decision into the technical tickets it impliesThe palette creates the Jira issues from your draft, one at a time, each behind a confirm you read first. When the shape repeats every sprint, build it once as a workflow: an agent drafts, then a single parallel step writes the ticket to Jira, the note to the squad channel in Slack and the entry to the architecture log in Confluence, all at the same moment.
- 15:30The slide for Thursday's architecture reviewYou have described the target flow in a paragraph on a slide. On macOS, Transform to diagram turns that text into an editable diagram with native shapes, a framework you can override and a palette you can match to the deck. You spend the remaining time on the argument, not on aligning boxes.
- 17:00Hand the whole thread to Claude Desktop or CodexThe bundled MCP server lets those tools read your live session, so 'what did we decide about idempotency on the payments integration' is answered from what actually happened today, not from what you can remember to paste. Or copy the recap and drop it into the handover document.
When the answer is the document,
not a block of text
An interface specification that has to go to a vendor is not improved by a chat window: you need the same file back, tightened. An agent that reads a document can also give one back. Tell it that its output is the edited file and it returns your .docx, .pptx, .xlsx or PDF rewritten, as a new file: your original is never opened for writing. Styles, slide layouts and images survive, because only the text is replaced and every byte of structure is written back by the app rather than by the model. Before you download it you see the paragraph diff, so you approve the edit instead of discovering it in the vendor’s reply. A run that could not keep something, a line that no longer fits its box in a PDF for instance, says so rather than quietly producing a worse page. The full mechanics are on the Documents page.
Build the architecture pack once,
then it is a keystroke
A saved agent is a prompt you never rewrite. Keep the ones this job actually repeats in a single pack: a decision record in your team’s shape, a constraint extractor for vendor documents, a non-functional requirements pass, a plain-language version of a technical note for the steering committee. You do not have to write those prompts from a blank page: describe the agent in one line and press Generate, then refine it with Improve. When a sequence repeats, chain it into a workflow of up to five steps, or describe the routine in plain English and let the workflow generator assemble it with the integration step already wired in. And because a pack is shareable, the second architect on the programme records decisions in the same shape as the first, which is the entire point of a decision log.
The four pieces you will use most
The parts of the job, one page each
Each one in depth, with the real features behind it.
Common questions from architects
Can it actually read a 60-page integration spec?
Yes. An agent can take a file as its input instead of your selected text: PDF, Word, PowerPoint, Excel, OpenDocument, EPUB, RTF, plain text and code, plus images, which go through the same text extraction as a screen capture. A small file is sent as it is. A long one is condensed once per version of its content and that condensed version is cached on your machine, so asking a second question about the same spec on Thursday costs nothing extra. When the file changes, it is redone. A scanned PDF with no text layer is reported as exactly that, rather than coming back empty and leaving you to guess why.
Will appending a decision to Confluence overwrite the page?
No, and that is the part worth understanding. Confluence has no append primitive, so writing one paragraph means reading the page and writing it back. Khint copies the existing content through untouched, adds your paragraph, and saves at the next version number. Macros, tables and layouts survive because nothing reinterprets them. That version number is also a lock: if a colleague edited the page while your agent was drafting, the write fails and tells you, instead of replacing their edit with an older copy. Commenting is a separate write that cannot touch the body at all, which is why spec review feedback goes in as comments.
Can it draw our architecture diagram?
Within a clear limit. On macOS you can switch on the PowerPoint companion, select the text of a slide, and Transform to diagram turns it into an editable slide: native shapes you can move, not a flat image, with layout variants and a colour palette. The layouts are the ones a review board expects, a flow, a process, a matrix, a timeline, a comparison, so it fits the decision slides you present. It is not a C4 model and it does not read your repository to infer a system map. It turns a flow you have already described in words into something presentable.
Where does our architecture documentation actually go?
The text of the action you run goes to the model, and the compact state of your work session goes with it only if you switched that on for that agent. Everything else stays on the machine: your session entries, the bodies of your run history, the condensed versions of the documents you read, and the credentials for Jira, Confluence, Linear, Notion, Slack and Gmail, which live in the operating system keychain. Any agent can also have PII redaction switched on, which replaces emails, phone numbers and similar identifiers before the text is sent.
Record the next decision properly
Free with 300 credits a month, about 10 AI actions a day. No credit card. Connect Jira and Confluence when you are ready: it takes an API token, not an administrator.