Kyvvu’s argument about AI security starts with a distinction: an agent can have permission to perform two actions separately while their combination creates an unacceptable outcome. Its proposed control follows the sequence of a task rather than examining each permission in isolation.
An AI News interview with co-founder Maurits Kaptein describes how agent mistakes can become actions affecting databases or communications, rather than merely incorrect text. The company’s primary materials explain its response, but they remain vendor descriptions rather than an independent demonstration of protection in every environment.
The relevant history changes the next decision
Kyvvu calls its system an Agent Security Kernel, or ASK. Its architecture description places a small policy-evaluation engine inside the agent’s own process. The company says the engine decides whether to allow, warn about or block an action before it executes, considering the task’s ordered history.
The illustrative case is an outbound message. The same message action can proceed during a task that has only read ordinary product information, but be blocked after a sensitive customer-data read. The difference is what happened earlier, not a newly invented identity or permission for the agent.
Kaptein tells AI News that Kyvvu examines actions taken by the harness rather than inspecting content. He describes deployments through integration partners in regulated Dutch enterprises. Those are attributed statements about the company’s approach and commercial footprint; the interview does not supply independent deployment results or a comprehensive failure rate.
The security question therefore becomes specific: which earlier event changes the next action’s status, and how is that event reliably recognized? Calling a system path-aware is not enough unless the relevant steps actually reach the enforcement mechanism.
The documentation separates decisions from reporting
Kyvvu’s introduction documentation describes translating agent events into behaviours, evaluating them in the local engine, and recording completed steps. Policy evaluation is described as CPU-only, with policies cached rather than fetched through a network request for each action.
The same documentation shows a separate reporting path. Behavioural traces are queued for asynchronous delivery to the platform when a task ends, supporting incidents and dashboard review. Local enforcement and subsequent reporting are different operations; describing the first as local should not make the second disappear from an architectural assessment.
The documentation also describes a bundled baseline and an account-free demonstration that blocks ungated code execution. These are documented starting points, not evidence that merely installing the package secures an arbitrary agent. Integration still determines which actions are represented and checked.
A log can show an event after it happens. A pre-execution decision can prevent it. An assessment needs to establish which mechanism handles each relevant action rather than treating observability and enforcement as interchangeable achievements.
The policy library reveals the choices underneath
The public manifest repository makes several kinds of path-dependent rules inspectable. Policies can block a forbidden sequence, require an earlier approval gate, consume a dedicated approval for each action, or limit cumulative usage within a task.
Those options are materially different. An approval that merely appears somewhere in history is not the same as an approval consumed by one specific action. The appropriate rule depends on what the organization intends to authorize, not just whether an approval event exists.
The repository also distinguishes registration checks from action-time checks and describes severity levels that produce warnings or blocks. A warning records a concern while allowing execution; it should not be reported as a prevented action.
This is the useful contribution of inspecting primary documentation alongside the interview: it turns a broad security promise into decisions that can be reviewed. The remaining test is whether the integration covers the actions that matter, the policies express the intended boundaries, and the resulting evidence shows those boundaries were enforced.










