What’s new in Neatlogs

You can now write custom function detections in neatlogs. Pick a target, write a function, and return a boolean. Your code runs against a snapshot of every span or trace in scope, and anything that returns true gets flagged.

Use it for checks that need your own logic, like marking traces where cost, latency, metadata, and span content combine in a way simple rules can’t express. You can also train a classifier on your own labeled spans and run it across your traces as a detection, giving you another way to catch patterns that are easier to recognize than hard-code.

Build custom AI evaluators with your own rubric and verdict schema. Use an LLM judge for a fast one-pass review, or an agent judge when the evaluation needs to inspect span data, call tools, or check external context first.

Agent judges can use connected integrations, custom MCP servers, or allowlisted HTTP fetches during review.

Test an evaluator against a real trace in the playground, then assign it per question alongside your human reviewers.

Evals now live at /evals, with old /feedback links redirecting automatically. Trace and span eval results are also exposed to agents querying over MCP, so evaluation outcomes can feed back into debugging and investigation workflows.

A span tree shows the shape of a run, but not how it played out. Replay lets you move through it in sequence, where it branched, where it stalled, what each step decided, which is usually faster than reading a static tree when you're trying to understand behavior.

A persistent shell wraps every replay: transport controls, a structure graph, a timeline that exposes concurrency and idle gaps, and an inspector for the selected step. Switch the center between a narrative Story walkthrough and a proportional Tree-plus-gantt view. It runs on your live traces or bundled demo architectures, and reads the same span data as Traces, so anything your instrumentation captures shows up with no extra setup.

A single trace tells you what happened in one run: it won't tell you that p95 latency crept up this week or which model is quietly driving your bill. Analytics gives you that aggregate view and groups recurring failures together, so a regression shows up as a trend instead of a surprise.

The dashboard is built from widgets you can show, hide, and reorder, a KPI strip, cost breakdown by model or workflow, tool latency, error clusters, and detection trends. One filter bar scopes everything by time range, workflow, model, tool, or detection, and every number drills straight back into the traces behind it, since it's all computed from the same span data.

Go from root cause to code fix without rebuilding context.

Finding the root cause is only half the job. The actual fix happens in your editor. Instead of switching tools and reconstructing the investigation, you can continue from where it left off.

Send any triage result directly to Cursor or Claude Code. The handoff includes the root cause, supporting evidence, affected traces, and recommended fixes, so your AI coding assistant has the context it needs from the start.

Evaluating a new observability platform shouldn't mean starting from an empty dashboard.

Neatlogs can now import traces from LangSmith and Braintrust, so you can explore your existing workloads from day one.

Imported data includes traces, spans, metadata, attributes, cost information, and source attribution for every trace. We also filter out low-signal infrastructure spans, making it easier to focus on your agents rather than the underlying framework.

Whether you're evaluating Neatlogs or planning a migration, your existing history comes with you.

Ask questions about your traces without writing filters or queries.

AI Search understands natural language, whether you're looking for a specific failure or investigating patterns across multiple traces. Use Fast mode for quick lookups or Pro mode for deeper investigations across spans and traces.

You can ask questions like:

• Show me traces where the agent failed to call a tool
• Find runs from last week where token count exceeded 10,000
• Which model generated the most errors today?

AI Search also remembers context within a session, so you can ask follow-up questions naturally without repeating yourself.

Protect sensitive information without sacrificing observability.

You can now redact PII before it leaves your application or before it's written to storage in Neatlogs. Built-in detection covers common entities like names, email addresses, phone numbers, and financial information, and you can choose which span types are affected.

Client-side redaction gives you complete control over what gets sent to Neatlogs, while server-side redaction uses Presidio to automatically identify and remove sensitive data before it's stored.

Update prompts independently of your application code.

Store prompts in Neatlogs and fetch them at runtime instead of hardcoding them. Test changes in the Playground before promoting them to production, keep a complete version history, and roll back instantly if needed.

If you're already using Langfuse, you can import your existing prompts from Experiments → Prompts → Import.

Keep every trace from a conversation together without managing session IDs yourself.

Enable auto_session and Neatlogs automatically groups all traces produced by your process into the same session. If you already manage conversation state externally, you can provide your own session ID instead.

Keep feedback attached to the trace instead of scattered across chat messages and issue trackers.

Comment directly on any output, failed tool call, suspicious span, or attribute. Every comment stays attached to the exact part of the trace you're discussing, making it easy to review findings and collaborate without losing context.

Use @mentions to bring teammates into the conversation and reactions to keep discussions organized.

See the complete execution path behind every request.

Neatlogs captures each agent run as a trace, showing the full span hierarchy, execution order, and where time was spent. Inspect prompts, completions, token usage, costs, timing, and other metadata for every span.

Whether you're debugging failures or investigating performance, traces give you the context you need to understand what happened.

Surface important runs without manually inspecting every trace.

Create detections using regex patterns, numeric conditions, built-in PII detection, or semantic classifiers. Matching runs are automatically labeled in the traces list, and you can filter by detection type to quickly review related issues.

Capture LLM calls, tool invocations, retrievals, and more without adding manual wrappers.

Pass the libraries you use to instrumentations and Neatlogs automatically instruments supported frameworks and SDKs. Just make sure neatlogs.init() runs before importing any instrumented library.