AI agents are proliferating. We're here to help.
A new, dynamic security model for the AI agent era.
Why we started Qpoint
Our team has spent most of our careers building developer platforms and running infrastructure at large scale. Along the way, we built tools that show what software is actually doing on the machines it runs on, which is often different from what the logs and dashboards say.
When AI agents started showing up on developer laptops and company servers, we pointed that same kind of work at them. An agent does its work in three ways: it reads and writes files, it runs commands, and it sends requests over the network. It does all of this as the person who started it, using that person's access and credentials.
The tools companies already had each saw only part of this. Endpoint tools could see processes, but they couldn't tell which ones were agents. Network tools and AI gateways could see the traffic that passed through them, but not what the agent did on the machine itself. As a result, most companies couldn't say which agents they were running or what those agents were doing, and they had no way to stop an agent from doing something it shouldn't. We started Qpoint to give companies both: a clear view of what their agents are doing, and control over what they're allowed to do.
Qpoint is a dynamic sandbox for AI agents. It runs on the same machine as the agent, between the agent and the operating system, so it can see every file the agent touches, every command it runs, and every request it sends. Qpoint records each of those actions along with the agent, session, and user behind it, and it applies the rules you set before an action is allowed to complete.
It works the same way on employee laptops running macOS, Windows, or Linux, on servers and in containers, Kubernetes, and CI runners, and inside other security products that build it in. Security teams, IT teams, and platform teams use it to understand and control the agents their people and systems are running.
Our goal is to let companies put AI agents to work with confidence, because they know what each agent did and they know it stayed within the rules they set. Qpoint is not an AI gateway, an LLM tracing tool, or a model governance platform. It is designed to work alongside those tools.
A handful of principles shape how we build Qpoint.
- We work underneath the agent. Qpoint sits between the agent and the operating system and covers all three ways an agent acts: files, commands, and network. The specific techniques we use vary from one operating system to the next, but the coverage is the same on all of them.
- We support any agent without changes. Qpoint recognizes agents by how they behave, so it covers Claude Code, Codex, agents a company built itself, and agents nobody approved. There are no SDKs to add, no wrappers to install, and nothing changes about how people use their tools.
- We make decisions one action at a time. Rules are applied to each action as it happens, rather than only to the environment the agent starts in.
- We ship one binary that runs everywhere. The same binary runs on laptops, servers, containers, and clusters, as well as inside partner products, and it produces the same stream of events in every case.
- We keep a record the agent can't change. Once Qpoint captures an action, the agent has no way to alter or delete that record.
- We keep your data with you. Events go only to the places you send them, and none of that data comes to Qpoint.
- We treat policies as plugins. You can use the plugins we ship or write your own, and anything Qpoint enforces can be extended or replaced.
Most of the sandboxes people use for AI agents today are static. A container, a virtual machine, or a set of permission prompts defines the boundaries before the agent starts, and anything inside those boundaries is allowed. That approach made sense for traditional software, which does roughly the same thing every time it runs. AI agents are different. They decide what to do as they go, they follow instructions they come across along the way, they start other agents, and they run in many places at once, from laptops to CI pipelines to production systems.
We think agents need a dynamic sandbox instead: one that looks at each action as it happens, based on what the agent is actually doing and the rules you have set, and that works the same way wherever the agent is running. That is what we are building at Qpoint. Our aim is a single layer that sits underneath every agent and makes it safe for companies to give agents real work to do.
We write about this as we build it on our blog, Underneath the Agent.
Infrastructure & Security Veterans
Founded by veterans of DigitalOcean, NS1, and HashiCorp with a shared obsession: building the infrastructure each new wave of technology demands.
Our Investors
Qpoint is backed by leading investors at the forefront of today's AI industry.
Our Advisors
Our advisors bring decades of experience from the companies that defined modern infrastructure, operations, and security.
