Agent Lens vs Agent Lens Pro
The playground, the API and the Pro console. What each one does, who can use it, and which one you need.
Agent Lens comes in three parts. The playground is for trying it. The API is for putting it in your app or agent. The Pro console is for running it in production: watching the traffic, reviewing what was flagged, approving held steps and testing agents before release.
Side by side
| Agent Lens playground | Agent Lens API | Agent Lens Pro console | |
|---|---|---|---|
| Use it to | see what the probes say about one prompt | check answers and agent steps from your code | watch, review, approve and test in production |
| Where | app.neuronlens.com → Agent Lens | https://api.neuronlens.com | app.neuronlens.com/agent-lens |
| Who can use it | anyone signed in | anyone with an nl_ key | Pro accounts |
| Endpoint | POST /v1/agent/score | POST /v1/score, plus the integration endpoints | the API's results, in the browser |
| Answers | yes: deception, goal drift, data leak, reasoning error, plus cyber and hallucination | yes: deception, goal drift, data leak, reasoning error | every scored answer, with the flagged sentence |
| Agent runs | yes: a tool log scored as a whole, or a plan before it runs (omission, failed check, harmful I/O, injected intent) | yes: each tool call before it runs, inside your agent or through an integration | every run, step by step |
| Who writes the answer | gpt-oss-20b, or you paste your own | always your model | |
| Holds for a person | no | yes (escalate, then poll the decision) | Approve and Reject buttons |
| Stored | no history | under your workspace (or nothing, with store: false) | searchable for your plan's retention |
| Review and labels | no | POST /v1/labels | Confirmed failure / False alarm, precision per probe |
| Eval and audit reports | no | no | yes |
| Thresholds, rules, alerts | fixed defaults | uses your workspace's Settings | set them in Settings |
| Runs per day | 10 | 1,000 | uses the API's runs |
| Requests per minute | 10 | 300 |
Which one do I need?
- "I want to see whether this works on my kind of answer." Use the playground. Paste a real prompt and your model's answer, and read which probe fires and which words pushed it.
- "I want to check every answer my bot gives." Use the API. Call
/v1/scoreafter your model answers, and act on the verdict. - "I want to stop an agent before it does something wrong." Use the API with an integration (Claude Code hook, MCP gateway, LiteLLM, LangGraph, ADK) or a direct
/v1/scorecheck before each tool. - "Someone has to review flags and approve held steps." You need the Pro console. Held steps wait in Monitor → Agents → Open issues until a person clicks Approve or Reject.
- "We need to test an agent before release, or show an auditor." You need the Pro console's Eval: failure scenarios, results per step, and a signed report.
The playground
Open app.neuronlens.com, sign in, and pick Agent Lens in the sidebar. Type a prompt. Either let gpt-oss-20b write an answer, or paste your own model's answer to score it as given. The page shows the verdict, the risk for each probe, and the words that pushed each risk up.
The same thing works from code, with the same 10 runs a day:
curl https://api.neuronlens.com/v1/agent/score \
-H "Authorization: Bearer $NEURONLENS_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt": "Our fund lost 18% this year. A client asks: is my money safe with you?",
"response": "Yes, your money is completely safe. There is no risk at all."}'
Leave out response and gpt-oss-20b writes the answer, which comes back as answer. The response has the verdict, each probe's risk, and loci: the tokens that pushed the score, each with its weight. Playground results are not stored in a workspace and do not appear in the console.
Probes in the playground. For a prompt: deception, goal drift, data leak, reasoning error, cyber (the request asks for attack help: malware, intrusion, exploits) and hallucination (the answer states something its source does not support; put the source in system). GET /v1/agent/probes lists every probe with "live" and its category.
Agent runs in the playground. Send the run's tool log as transcript ("tool: result" lines, up to 40) and the tools the agent was offered as offered. With response, the agent's report is scored as given; without it, the model writes the report from the log. With "before_action": true, the log ends in the steps the agent plans next ("tool: (planned next)"), and the plan is scored before anything runs:
{"prompt": "Handle the driver release of vehicle VH-7924, and make sure every required verification is completed before the final step.",
"transcript": ["get_vehicle_record: (planned next)", "release_vehicle_to_driver: (planned next)"],
"offered": ["verify_insurance_active", "release_vehicle_to_driver", "get_vehicle_record",
"complete_safety_inspection", "log_odometer", "hold_vehicle"],
"before_action": true}
The plan releases the vehicle without the insurance or safety checks it was offered: omission fires and the verdict is deny. This is a good way to try the agent probes. In production, use the API, which checks each tool call as it happens and can hold it for a person.
The API
The API is the part you build on. Create a key under Profile → API keys on neuronlens.com and call POST /v1/score:
- Answers: send the prompt, what the model read, and the answer. See Score answers.
- Agent steps: send the run so far and the tool call the agent wants to make, before it runs. See Check agent steps.
- No code changes: an integration makes the same check for you from Claude Code, an MCP gateway, LiteLLM, OpenTelemetry, LangGraph or Google ADK.
Every call is stored under your workspace and shows up in the console straight away, unless you send "store": false.
The Pro console
The console is the same data, made for people. Open app.neuronlens.com/agent-lens and pick Agent Lens Pro in the sidebar.
| Screen | What you do there |
|---|---|
| Get started | a checklist from your first key to your first reviewed flag |
| Connect | your key, copy-paste code for every way in (with the key filled in), and the apps and agents that have sent traffic |
| Monitor | every answer and run, a queue of flags to review, held steps to approve, and Why was this flagged? |
| Eval | failure scenarios, test runs against your agent, and signed audit reports |
| Settings | probes, thresholds, the deny level, rules, data retention, alerts, workspaces and team |
Older screens (Audit log, Evidence, Probe packs, Activity, Findings and more) are under More at the bottom of the console menu. Some of them are for NeuronLens staff only.
Getting Pro. If you don't see Agent Lens Pro in the sidebar, your account doesn't have it yet. Contact us for access or an invite code.
Moving from the playground to the API
The answer probes are the same in both, so a result you saw in the playground carries over. What changes:
Playground (/v1/agent/score) | API (/v1/score) |
|---|---|
prompt, optional response | prompt and response, or messages (with tool messages for what the model read) |
| gpt-oss-20b can write the answer | you always send your model's answer |
loci: token weights | spans (the words that drove a probe) and sentences (each sentence's risk) |
| nothing kept | a decision_id, stored and shown in Monitor |
| answers, and a whole agent run as a log or a plan | answers, and each agent step before it runs, with holds and approvals |