Every requirement,traceable to its source
Six weeks later, someone asks why a requirement is the way it is. Khint keeps the answer: as you capture, draft, and file, the Memory session records each step as a timestamped entry: a lightweight provenance trail you can search, kept locally on your machine.
“Wait, why did we
decide that?”
A requirement is only as trustworthy as the trail behind it. When a developer questions an edge case, an auditor asks for the origin, or a stakeholder reverses a decision, the burden falls on you to reconstruct where the requirement came from, usually from memory, a buried chat thread, and a photo you can no longer find. Khint won't hand you a formal traceability matrix, and it doesn't claim to. What it does is record the work as you do it: Capture logs the source, Agents log the draft, the integrations log the ticket, and Memory holds it all in one ordered, searchable session, built as a by-product of getting the work done, not as bookkeeping you keep on the side.
One requirement, end to end
What a single session entry log looks like as the work happens.
Whiteboard: refunds allowed within 30 days, EU customers only
Drafted: “The system shall permit refunds for EU customers within 30 days of purchase.”
Created issue PAY-418 from the drafted requirement
“Which session first mentioned the EU-only refund rule?” → this one
Illustrative: entry types and text reflect whatever you actually capture, run, and file.
Build the trail as you build the requirement
A refunds-policy review, from the call to a question months later.
Open a session named after the requirement's source
Before the discovery call, start a Memory session: “Refunds policy review, Q3”. From here, every capture and every Action you run is logged to that session as a timestamped entry, in order. The session is the container the trail lives in, so name it after the thing you'll need to trace back to later. How Memory works →
Capture the source, so the origin is on record
The sponsor states the rule out loud and sketches the edge cases on a whiteboard. Hit Cmd+Shift+K, pick Extract text, and drag a region over the board. The text is OCR'd to your clipboard and the capture lands in the session log. Now the requirement's origin is recorded, not just remembered. How Capture works →
Draft the requirement: that run is logged too
Select your raw notes and run an Action from your pack: a requirement-extraction or user-story prompt. Because the session context rides along, the draft already knows the call it came from. And the run itself is logged as an entry, so the trail now reads “captured the board → drafted this requirement” in sequence. How Agents work →
File it: the ticket joins the same trail
With Atlassian or Linear connected, create the Jira issue or Linear ticket straight from the palette. That write logs its own entry (the issue key it created) into the same session. The trail now closes the loop: source captured, requirement drafted, ticket filed, all in one ordered record. How integrations work →
Ask your AI client to trace it back, months later
When a change request lands and someone asks why the rule is EU-only, let Claude Desktop or Codex read the session over Khint's MCP server: it can search the entry log and surface the exact capture and draft that requirement grew from, without you scrolling a chat history. How the MCP server works →
A trail that stays on your machine
Provenance is sensitive: it names the stakeholders, the decisions, and the wording before it was polished. So Khint keeps it local: Memory sessions and their entries live in a SQLite database on your device and are never synced to the cloud. Your action history keeps the full input and output text locally too; only lightweight metadata ever syncs. And an Action only ever sees the text you selected plus the compacted session summary you opted into. Nothing else leaves your machine silently. The audit trail you build is yours, on your laptop, searchable by your own AI client over the MCP server whenever you need to answer for a requirement.
Common questions
Does Khint give me a formal requirements traceability matrix?
No, and it doesn't pretend to. Khint is not an RTM tool. What it gives you is the raw material an audit trail is built from: a Memory session records every capture and every AI action you run as a timestamped entry, in order, with the type of each (a screen capture, a drafted requirement, a filed Jira issue). When someone asks 'why is this requirement here', you have a chronological record of the call it came from and the ticket it became, not a spreadsheet you maintained by hand.
Where is the trail stored: does it leave my machine?
Memory sessions and their entries live in a local SQLite database on your machine and are never synced to Khint's servers. Your action history (the input and output text of each run) is also stored locally; only lightweight metadata syncs to the cloud, and the actual note bodies never leave the device. So the provenance trail for sensitive requirements stays on your laptop.
Can I search the trail later to find where a requirement came from?
Yes. Khint ships an MCP server, so an AI client like Claude Desktop or Codex can read your sessions directly: list sessions, open one, pull its active context, or search session entries by keyword. So months later you can ask 'which session first mentioned the EU-only refund rule?' and the model searches the entry log for you, instead of you scrolling a chat history.
How does a requirement get into the trail in the first place?
However you already work. Capture a whiteboard or screenshot with the Capture pillar, run an AI Action on your raw notes to draft the requirement, and, with Atlassian or Linear connected, file the ticket from the palette. Each of those steps logs an entry into the active session automatically, so the trail builds itself as a by-product of doing the work, not as separate bookkeeping.
Stop reconstructing, start recording
Free with 10 AI actions and 5 captures per day. No credit card. Open a session, capture the source, let the trail build itself.