Performance and diagnostics

How Neoo measures its own speed, where the local performance journal lives, what leaves your computer, and how to ask an agent for the performance scoreboard.

Neoo times its own everyday gestures — opening a conversation, sending a message, starting the app — and gives each measurement a score. This page explains what is recorded, what stays on your computer, and how to read the result when Neoo feels slow.

What Neoo measures

Each measurement has a name, a category, a duration and, when a target is defensible, a target. The gestures you feel most are called journeys, and each one has a target for the typical (75th percentile) run:

JourneyWhat is timedTarget
app-launchFrom the process starting to the main window and the first composer being painted3 s
conversation-newClick on a new conversation to an empty, ready thread300 ms
conversation-openClick in the sidebar to a reopened conversation with its history painted500 ms
message-sendEnter to your message bubble being painted100 ms
message-dispatchEnter to your prompt being handed to the provider250 ms

first-event and first-token are also measured, but they depend on the provider and are not scored.

How the score works

  • A measurement at or under its target scores 100.
  • Above the target, the score is 100 × target ÷ duration, so a run twice as slow as its target scores 50.
  • An error, a failure or a timeout scores 0.
  • A measurement without a target is recorded but never scored.

The overall score is the average of the scored measurements. It tells you where to look, not how good a single run was: check the number of samples and the failure count before drawing a conclusion.

What stays on your computer

Neoo writes a local journal, telemetry.jsonl, in its data folder:

SystemInstalled app
Windows%APPDATA%\com.vato.ide\telemetry.jsonl
macOS~/Library/Application Support/com.vato.ide/telemetry.jsonl
Linux~/.local/share/com.vato.ide/telemetry.jsonl

The journal rotates at 32 MiB and keeps a single backup, telemetry.jsonl.1. It never leaves your computer.

It holds names, durations, targets, scores, counters and technical identifiers. It never holds your prompts, an agent's replies, message content, file names or paths, tool inputs or outputs, keystrokes, screenshots, tokens, cookies or passwords. The native side redacts and truncates every attribute a second time before writing it.

What is sent to Neoo

The desktop app installed from a release, while you are signed in, sends a small batch of aggregated counters and duration histograms to Neoo's API about once a minute. The batch uses a fixed list of metric names and carries your operating system and the app version. It carries no user, machine, session, project or conversation identifier.

  • Nothing is sent from a development build or from the browser-only version of the interface.
  • The upload is best effort and happens in the background: no action of yours ever waits for it, and a failure is silently retried later with a growing delay, up to 15 minutes.
  • The mobile app sends its own timings — boot, resuming, the realtime connection, the conversation list and detail, the keyboard, and prompt acknowledgement — through a closed list of measurements. No conversation content is accepted.

Because the aggregates are anonymous, Neoo cannot count unique users or find a particular person's session from them. A missing measurement does not prove that everything is healthy: a computer that is offline, signed out, or that crashed before its first upload sends nothing.

Ask an agent for the scoreboard

You do not have to read the journal yourself. Ask any agent — for example "How is Neoo performing? What is slowest?" — and it can call the perf_scoreboard tool. It is read-only, so it is also available in Plan mode.

By default it reads the journal on your computer and returns:

  • the overall score and the number of failures;
  • each journey with its typical (P50, P75, P95) durations against its target, and the share of runs within target;
  • the slowest categories and the worst scored events;
  • recovered freezes, resource alerts and the Tauri commands that spent the most time.

It never returns prompts, file paths, session identifiers or the raw attributes of an event.

OptionValuesDefault
scopelocal (this computer), fleet (Neoo's production aggregates), bothlocal
sourceinstalled (the installed app), dev (a development build), auto (the most recently written)auto
sinceMinutesTime window, up to 10 080 (seven days)1 440 (24 hours)
categoryOne category or prefix such as journey or tauri.command; for fleet, a metric prefix such as agentall
limitRows per ranking, up to 205

The tool is not offered in a Neoo Connect runner, in a Neoo Cloud Bot or in Neoo Design.

Background refreshes

Status panels keep themselves up to date in the background: Git branch and upstream badges, local servers, the mobile simulator, provider delivery checks, Neoo Design sync. To keep the window responsive, these refreshes follow three rules:

  • Workspace tab not on screen: its panels stop refreshing. They catch up as soon as you switch back to the tab.
  • Window without focus (for example Neoo on a second monitor while you type elsewhere): panels still refresh, about four times less often.
  • Window minimized: background refreshes stop and resume when the window is restored.

Actions you trigger yourself — sending a message, opening a panel, a local Neoo Design edit — are never delayed. A Git folder that cannot be read is retried at most every 5 minutes, and a provider usage reading that keeps failing is paused for 10 minutes.

Follow-up messages reuse the Claude session

After Claude answers in a conversation, Neoo keeps that conversation's Claude process ready for 25 minutes instead of closing it. Your next message goes straight to the running session: Claude Code, its tools and its shell do not have to start again, so the first command of the next turn runs as fast as the following ones.

  • When a new process starts anyway: after you change the model, reasoning effort, mode, provider account or project folder, after editing or reverting a message, in Plan mode, with /compact, and for Bots, Neoo Design, Remote Workspace and Team conversations. These keep one process per message, as before.
  • Memory: each ready session uses about 450 MB (Claude Code, Neoo's bridge and its tool server). Neoo keeps at most 4 ready sessions; the one idle the longest is closed first. Stopping a conversation, archiving it or quitting Neoo closes its ready session.
  • Claude only for now: Codex, Cursor and the other providers still start a process for each message.

If Neoo still feels slow

  1. Ask an agent for the scoreboard and note which journey is furthest above its target.
  2. Compare like with like: a development build runs unbundled code and reads slower than a release. Use source: "installed" to look at the installed app only.
  3. If you see recovered freezes or a very high number of calls for one command, mention them when you contact support@vatoide.com.
  4. Free up memory and stop project services you no longer need — see Not enough memory.