Deterministic capture beats AI guessing
Knovvy builds step-by-step guides from real browser events, not from looking at pixels. Here is why that architectural choice matters more than it sounds, and where AI genuinely earns its place.
There are two ways to turn a screen recording into a written guide. You can watch the video and infer what happened, or you can be present while it happens and record what actually did.
The first is more impressive in a demo. The second is the one you want documenting your payroll process.
What inference gets wrong
A model watching a recording has to answer questions the pixels do not contain. Did the user click that button, or move past it? Is that a dropdown opening or a page loading? What is this element called, given that the label is an icon? Was that pause a moment of thought or a network request?
It will produce plausible answers to all of them. Plausible is the problem. A guide that is ninety percent right reads exactly like a guide that is one hundred percent right, and the difference only surfaces when someone follows step seven into a wall.
What the browser already knows
Meanwhile, the browser has the actual answer sitting right there. When you click something, a real event fires on a real element. That element has an accessible name, or visible text, or a placeholder. It has exact coordinates. It lives on a page with a title and a URL.
So Knovvy captures from events rather than from pixels:
- The instruction comes from the element you actually interacted with, using its accessible name first, then its text, then its placeholder or title.
- The click highlight sits on the real bounding box, not an estimated one.
- Typing collapses into one step per field when the value is committed, because the browser tells us when a field changed, rather than a model deciding which keystrokes belonged together.
- Each step knows the page title, hostname, and URL it happened on, which is how a guide can name itself after the tool and the task.
The result is not just more accurate. It is identical every time you run it, which is a property inference cannot offer at any model size.
The security consequence nobody expects
This choice pays off somewhere surprising: redaction.
If you are inferring from pixels, deciding whether something is a password means a model looking at an image and forming an opinion. That opinion is probabilistic. Sometimes it will be wrong, and the failure mode is a credential in a screenshot that got shared with a contractor.
From the DOM it is not an opinion at all. A field is sensitive if it is type="password", or its autocomplete is one-time-code or cc-number or cc-csc, or its name, id, label, or placeholder matches a keyword list. That check runs the same way on every capture forever, and it runs before anything is uploaded.
The honest limit: this catches form fields, because that is what the DOM describes. A secret rendered as plain page text is not something the browser marks as sensitive, so you blur it yourself in the editor. We would rather state that clearly than imply a guarantee we cannot keep.
So where does AI belong?
Not nowhere. There is a real dividing line, and it is about whether a wrong answer is detectable.
If a generated summary is a bit off, you read it and notice. If a chapter marker is ten seconds early, you scrub. If a title is bland, you rename it. These are places where the human is already reviewing the output, so probabilistic is fine and genuinely useful.
Structure is different. If step four is subtly wrong, the person following it six months from now has no way to know, because they are following the guide precisely because they do not know the process. That is where determinism has to win.
So capture is deterministic and free of any model call, and generation is where AI lives. A practical consequence: you can run Knovvy end to end and never touch a model at all. That is not an accident of the free tier, it is what falls out of building capture this way.
The full breakdown of what is deterministic and what is not is on the security page.