Sensors
A sensor observes a change, or the system the change lives in, and reports a signal about its quality: pass or fail, a score, or a list of findings. It never changes the work.
Computational 26
- 1 Agent activity
Watches the agent's own tool calls and sessions, and reports the patterns that mean it is in trouble.
- 2 API compatibility check
Compares the public interface of a change with the last release, and reports every change that breaks a caller.
- 3 Browser run
Drives a scripted flow through a page in a real browser, and reports the step that broke.
- 4 Build and type check
Compiles the code or checks its types, and reports each error with its place.
- 5 CI results
Reads the results of the project's CI for a commit: which jobs passed, which failed, and the failing step's log.
- 6 Coverage and mutation
Shows what the tests do not check: lines no test runs, and changes to the code that no test notices.
- 7 Delivery flow metrics
Measures how work flows through the project over weeks: how long changes wait, how soon they get a first review, how old the backlog is, how much CI costs.
- 8 Dependency graph
Measures the graph of imports between modules (cycles, fan-in, fan-out) and compares it with an approved baseline.
- 9 Error tracker
Reads the errors real users hit, grouped into issues with stack traces and counts, and whether they came back after a fix.
- 10 Eval set
Runs an agent, a prompt or a skill many times on cases with known answers, and reports how often it gets them right.
- 11 Input and fault injection
Feeds the code generated inputs or broken dependencies, and reports the smallest case that makes it fail.
- 12 Isolation probe
Checks from inside an agent's environment that it is isolated: no network it should not reach, no secrets it should not see, nothing left after teardown.
- 13 Linter
Checks code against rules, and names each violation with its place and how to fix it.
- 14 Logs
Queries the logs of a run or a release, and reports the errors in them, grouped and counted.
- 15 Loop outcomes
Reads the record of what the loops caught and missed (escapes, corrections, releases not confirmed) to find the loop that should have caught a problem earlier.
- 16 Manual probe
Checks one hypothesis on real values: a call in a REPL, a breakpoint in a debugger, a request with an HTTP client.
- 17 Metrics and SLOs
Queries the service's metrics (error rates, latency, resource use) and compares them with a limit, an SLO or the previous version.
- 18 Performance measurement
Measures time, memory, size or load against a baseline or a budget, and reports what got worse.
- 19 Repository state
Reads the repository's state and diff directly, instead of taking the agent's word for what changed.
- 20 Screenshot and recording
Captures what the interface looks like, as an image or a video, for a comparison or as evidence.
- 21 Security scanner
Scans code, history, dependencies or a running app for known security problems and licence breaches.
- 22 Smoke and health probe
Starts the built artifact or reaches the deployed release, and checks that it answers and that its main paths work.
- 23 Structure check
Checks a file that has a required shape (a config, a schema, a CI workflow, a spec, a changelog, a release artifact) against that shape or a policy.
- 24 Terminal run
Drives a terminal app through a scripted session at a fixed size, sending keys and reading the rendered screen.
- 25 Test runner
Runs the project's tests on the changed code and reports which pass and which fail.
- 26 Traces
Queries the traces of requests through the system, and reports the spans that failed or took too long.
Inferential 2
- 1 LLM judge
A model scores a result, a screenshot, a sample of logs or the risk of an action against a rubric.
- 2 LLM reviewer
A separate agent with a fresh context reads a diff, a document or some code against a checklist or a policy, and lists what it finds.
Human 4
- 1 Human answer
The agent asks a person a structured question (approve a plan, choose an option, confirm a risky action) and gets an answer it can act on.
- 2 Human review
A person looks at the result (the diff, a demo, a sample of the agent's work, the product itself) and says whether it is what was wanted.
- 3 Live supervision
A person follows the agent's work as it happens, and interrupts when it drifts.
- 4 User feedback
Reads what real users say and do (feedback, support tickets, experiment results) in aggregate, with counts.