AI agents are not chatbots. They take actions - execute commands, call APIs, modify files, deploy code, manage infrastructure. When a chatbot hallucinates, you get wrong text. When an agent hallucinates, you get a wrong action executed in your live environment. The stakes are fundamentally different, and so is the required prevention.
Tool-use hallucination. The agent hallucinates which tool to use, or hallucinates the arguments to pass to a tool. It calls an API with fabricated parameters. It executes a command with a hallucinated file path. The tool exists. The arguments are wrong. Research shows tool-use hallucination occurs in up to 11.6% of agent interactions.
State hallucination. The agent has an incorrect model of the environment's current state. It believes a service is running when it is not. It believes a file is at a path where it does not exist. It believes a configuration is set to a value it is not. Every subsequent action is based on this false premise.
Plan hallucination. The agent generates a multi-step plan where one or more steps are based on fabricated assumptions. Step 1 works. Step 2 works. Step 3 assumes a state that steps 1 and 2 did not create. The plan looked coherent when generated. It fails at execution because reality diverged from the plan's assumptions.
Capability hallucination. The agent hallucinates that it has access to tools or permissions it does not have. It generates a plan that includes calling an API it cannot access, or executing a command that requires permissions it was not granted. The plan fails - or worse, the agent tries to work around its lack of access in ways that create security risks.
Check is literally that layer: context injection of real-time machine states before the AI reasons, and command verification against the live environment before the AI acts. The agent operates from reality, not from its model of reality.
Layer 1: Pre-flight context injection. Before the agent reasons about what to do, read the actual state of the environment and inject it into the agent's context. What OS is running. What services are active. What files exist at what paths. What configurations are set to what values. The agent does not guess the state - it reads the state.
This prevents state hallucination. The agent cannot hallucinate that a service is running when its context contains the actual service status showing it is not. It cannot hallucinate a file path when its context contains the actual directory listing.
Layer 2: Command verification. After the agent generates a command, validate that command against the live environment before execution. Is the target file at the path specified? Is the service in a state where this command is valid? Does this API call have the correct parameters for the current state? Is this action within the agent's authorised scope?
This catches hallucinated actions. Even if the agent's reasoning is wrong, the command is checked against reality before it runs. A hallucinated command that targets a non-existent resource is caught. A command that would be destructive in the current state is flagged.
The common approach to agent safety is "always have a human approve actions." This works at low volume. It does not scale. An agent executing 50 commands per task, across 100 tasks per day, cannot have each command manually reviewed.
More importantly, human reviewers make the same mistake users make: they evaluate whether the command looks right, not whether it is right for the current state. A command that looks perfectly reasonable - apt install nginx - may be wrong if nginx is already installed, or if the system uses a different package manager, or if a conflicting service is running on port 80.
Automated verification against live state catches what human review misses: the gap between what the command says and what the environment actually is. Check provides this - machine-speed verification at every action, not human-speed review at selected actions.
For text output, detection is a reasonable approach - flag likely hallucinations and let the user decide. For agent actions, detection after execution is too late. The file is already modified. The service is already restarted. The deployment is already running.
Agent hallucination requires prevention, not detection. Verify before the action executes. Ground the agent in the live environment before it reasons. Check every command against reality before it runs. This is what Check was built for - the verification layer between AI reasoning and real-world action.
120 verifications a day free. No card, no signup.