Investigate

Investigate is a Neat AI agent that looks into your agent's behavior for you. Instead of building filters, you ask it a question in plain language and it runs a multi-step investigation across your traces — reading inputs, outputs, token usage, latency, detections, and metadata — then reports back with the evidence it found and, when it surfaces a real problem, a fix you can act on.

It runs in two modes:

• Fast — quick answers for straightforward questions.
• Pro — deeper, multi-step reasoning for complex or ambiguous questions that need context pulled together across many traces.

What you can ask

Investigate is conversational — open a thread and ask anything about your runs:

"Start an investigation on last 100 traces"
"Analyze why there are so many negative detections"
"Find traces with high latency"
"Summarize user checkout flows"
"Identify database bottlenecks"
"Find filled eval forms from yesterday"
"Show me runs where the agent failed to call a tool"
"Which runs cost the most, and why?"

It works across content, behavior, cost, latency, and detections — not just metadata.

How an investigation works

When you ask a question, the agent runs a sequence of steps and streams its reasoning live — each tool call and the traces it pulls in as evidence appear as the investigation unfolds. The relevant runs are linked directly, so every conclusion is backed by the actual trace data, not a generic answer.

The view is split: a chat thread on one side and an investigation canvas on the other that lays out the steps, linked traces, and findings.

Threads are stateful — once you have a result, ask a follow-up to drill in without restating the context:

"Of those, which ones had the highest cost?"
"Filter to only the ones from the last 24 hours"
"Which had a tool call that returned an error?"

Your investigations are saved as threads, so you can reopen a past investigation with its evidence intact.

From investigation to fix

This is where Investigate connects to the rest of Neatlogs. When an investigation surfaces a real problem, it produces a fix suggestion in Fixes — a concrete fix with root-cause reasoning, attached to the investigation that found it. You can review it, accept or reject it, and dispatch the accepted fix to a coding agent that opens a pull request.

So Investigate isn't just for answering questions — it's the front door to fixing what it finds. The investigation you run here is the same investigation trail that backs a fix, which is why a coding agent can re-hydrate the full context through the MCP server when it picks the fix up.

Next

That fix is where the loop continues — read Fixes next to see how a suggestion gets reviewed and shipped — or wire up the MCP server so your coding agent can act on it from your editor.