v1.10.0

Proxytrace 1.10.0

Proxytrace 1.9.0

Fixed

• The documented image address works again. Every published reference to the container image —
  the compose file shipped in the release artifact, the one-line docker run in the README, the
  installation, deployment and upgrade pages of the manual — pointed at
  ghcr.io/proxytrace/proxytrace, a GitHub Container Registry owner that stopped existing when the
  organisation was renamed to SyntaktikEU. Pulls against it fail with owner not found, so a new
  operator following the quick start got a registry error instead of a running Proxytrace. All of
  them now name the canonical ghcr.io/syntaktikeu/proxytrace, which is where the images have
  actually been published. The Docker Hub address, proxytrace/proxytrace, is unchanged and was
  never affected.

• A test run no longer hangs forever because one case failed. A case whose model call threw was
  deliberately skipped so the rest of the run could continue — but the run counted results to decide
  it was finished, and the skipped case never produced one. The run therefore sat at Running for
  as long as the server stayed up, while the group it belonged to already read Completed, and a
  restart did not clear it. Runs are now settled once every case has been attempted: Completed
  when all of them produced a result, Failed when any were skipped — visibly incomplete instead
  of eternally in progress. Runs already stranded this way are cleaned up on the next start.

• A broken judge no longer reads as a failing test case. When an LLM evaluator errored, the case
  it was scoring counted as not passing, so a crashed judge was indistinguishable from an agent
  that behaved badly — it dragged the run's pass rate down and could turn an optimization theory into
  "could not test". A case is now decided by the evaluators that actually returned a verdict; errored
  ones are left out, and a case is only unjudged when every evaluator on it errored.

• A long-winded LLM judge no longer throws away its own verdict. An evaluator that talked past
  its output budget had its answer cut off mid-sentence, which made the whole response unreadable —
  including the score it had already given. Judges are now asked to keep their reasoning brief, a
  failed judge call is retried once, and an answer that was cut off is repaired and read rather than
  discarded, so the verdict survives even when the explanation does not.

• Opening a trace from a link now scrolls the list to it. Following a trace link — from an
  anomaly, a notification, or Tracey — opened the detail drawer but left the list showing the newest
  traces, so the row you were sent to was never highlighted or brought into view. The older the
  trace, the more likely it was. The list now loads until it reaches the linked trace and scrolls it
  into the middle of the view, with the surrounding traces around it.

• A session's trace and token counters now go down when traces are deleted. They were only ever
  incremented, so deleting a trace — by hand, or because it passed the retention window — left the
  session header claiming more traces than its timeline could show, permanently. Both retention and
  the delete action now give back exactly what the removed traces contributed.

• Sessions no longer accumulate forever. Session rows outlived their traces indefinitely, so a
  client that mints a fresh session key per run grew the table without bound — including sessions
  whose traces were long gone. The nightly trace cleanup now removes sessions whose last activity has
  passed the same retention window, which by definition means every trace they grouped is already
  gone. Sessions with recent traces are never touched.

• Edits to an agent no longer fail for minutes after a busy save. Under concurrent traffic — an
  agent being updated while its traces were still arriving and the UI was open — the in-process entity
  cache could refill with the pre-save version of a row and keep serving it for up to five minutes.
  Every write attempted against that stale copy was rejected as a conflict, so ingestion retried and
  saves failed for no visible reason. Cached entries are now dropped again once the save commits, so
  the stale copy cannot outlive the write that replaced it.

• The proxy logs each upstream request once, not four times. Every call your agents made through
  the proxy emitted four identical sets of HTTP client log lines, quadrupling the volume on the
  busiest path in the system and making proxy logs hard to read during an incident.

• Proxytrace is documented as source-available, consistently. The Docker Hub overview still
  declared the product Proprietary, contradicting the Elastic License 2.0 relicense in 1.5.0 — the
  first licensing statement most evaluators read. It now states the ELv2 terms, the README carries a
  matching License section, and every documented GitHub link (plus the release-manifest URL the
  update check calls) points at SyntaktikEU/Proxytrace instead of relying on GitHub's rename
  redirect.

• The install quick starts now advertise the project-scoped proxy URL. The installation page,
  the Docker Hub overview and the deployment artifact's README, compose file and .env template all
  told new users to point their agents at http://localhost:5102/openai/v1 — the legacy unscoped
  form, which only works with a Proxytrace-issued key. Anyone following the documented one-line
  migration, keeping their existing upstream provider key, got a 401 instead of a trace, because
  the project is read from the URL path in that case. All five now point at the project-scoped
  endpoint the setup wizard hands you, http://localhost:5102/{project-slug}/openai/v1, matching
  what the manual's Proxy Setup page has always defined as canonical.

• The licensing manual no longer overstates the Free tier. It advertised 3 users while the
  code allows 1 — and contradicted its own tier table further down the page — so an operator
  could plan a three-person pilot and hit a blocked invite on the second seat. The page now says one
  user, explains that this effectively disables user management until an upgrade, and lists the
  scheduled test runs and custom anomaly detectors that were missing from the Enterprise column.

• Expanded multi-turn conversations no longer overlap the rows beneath them. Opening a
  conversation's turns while new traces were streaming in left the expanded turns painted on top of
  the following rows, with the text of both stacked on itself. The table measured each row by its
  position in the list, so an arriving trace — which shifts every row below it down a slot — handed
  an expanded group's height to whichever row inherited its old position. Rows are now measured by
  identity, so they keep their own height however the list shifts around them.

• A newly captured trace no longer redraws the whole Traces table. While you watched the list at
  the top, every arriving call blanked the table back to loading skeletons and rebuilt it — a flicker
  on every request your agents made, and it threw away the rows you had already scrolled in. Arrivals
  are now inserted in place, among the rows already on screen, and briefly highlighted so the new
  one is easy to spot. Nothing else moves. A burst of calls is collected into one insert rather than
  one reload each, and under a metric sort (slowest-first, say) the new trace lands where it actually
  ranks instead of jumping to the top. A duplicated row that could appear after new traces arrived
  and you scrolled on for the next batch is fixed with it.

Added

• Ask Tracey a specific question from a trace. The trace detail action now opens a multiline
  question box instead of immediately sending a generic analysis request. Ask what matters for the
  call, such as why a refund was approved, and Tracey starts a fresh conversation with the trace ID
  and your exact question.

• Tracey writes the failing test before she proposes a fix. Report a defect in a captured call —
  "the agent in trace 5b71… approved a refund even though the return window had expired" — and
  Tracey now works it test-first. She reproduces it from the real conversation (and stops if the
  trace doesn't show what you described), states the rule that was broken, then turns it into a
  test case whose expected answer is what the agent should have said rather than what it did
  say, attaching an LLM judge that can actually score that rule. She runs the suite and checks that
  specific case: if it unexpectedly passes, the test doesn't capture your bug and she fixes the
  test, not the agent; if the evaluator itself errored she says so, because a broken judge is not
  evidence the agent was wrong. Only with a confirmed failure does she propose a change, and when
  the background A/B test finishes she checks your case again against the candidate to show it move
  from failing to passing. Anomaly detection can only flag calls that look unusual; this covers
  the ones that look perfectly normal and are simply wrong.

• Tracey can read a whole trace. Asking Tracey about a captured call previously gave her only its
  headline numbers (model, status, tokens, latency, cost) — enough to describe the call, but not to
  read it. She can now pull the complete trace instead: every message of the request (system
  prompt, user turns, assistant replies, tool calls and their results), the full response, the tool
  schema the agent was offered, and the model parameters the call ran with. So "why did this call
  fail?", "what was this agent actually told?" and "summarize this trace" are answered from the real
  conversation rather than from metadata, and trace-driven work — diagnosing anomalies, grounding an
  optimization theory, ...

Proxytrace 1.7.0

Added

• Scoped API keys for the REST API. A Proxytrace API key can now drive /api/* directly, so an
  external service no longer needs a long-lived user login (with MFA disabled and a token-refresh loop)
  to call the API. Mint a key with the new REST API read and/or REST API write capabilities:
  read keys may issue GET requests, write keys may also create and change data. The key acts as its
  owner and, like an MCP key, can never reach admin-only endpoints. Capabilities stay least-privilege
  and are not interchangeable across surfaces — a REST key cannot drive MCP or proxy LLM traffic, and
  existing keys are unaffected. (#365)
• Record corrections over MCP. The add_trace_to_suite tool now takes an optional expectedOutput.
  Provide it to log a correction — "the agent saw this input, and the right answer was X" — turning a
  captured trace into a regression test, instead of only promoting the trace as-is. An external agent
  can now drive the entire capture → correct → propose → validate loop with a single scoped MCP key. (#366)

Changed

• The proxy now forwards client headers transparently. LLM requests through the ingestion proxy
  previously only passed a small fixed set of headers to the upstream provider; everything else was
  dropped. Now every header travels upstream unchanged — OpenAI-Beta, openai-organization,
  idempotency keys, custom tracing headers, and anything else your provider expects — so an existing
  client can swap its base URL to Proxytrace with no behavior change. Only Proxytrace's own
  x-proxytrace-* control headers, credentials (replaced with the provider's real key), and
  hop-by-hop/connection headers are stripped. Upstream response headers are relayed the same way, and
  Azure OpenAI upstreams now also receive the provider key in the api-key header that Azure's
  classic data-plane auth expects.
• Test cases now remember which trace they came from. Promoting or correcting a trace into a test
  suite records a link back to the source trace, so "which trace produced this case?" is answerable from
  Proxytrace's own data. (Previously the link was silently dropped, despite the API documenting
  otherwise.) Synthetic cases built from raw input and expected output have no source and are unaffected. (#367)

Proxytrace 1.6.0

Added

• Install with a single docker run. Proxytrace now ships as one image containing the
  whole product — web UI, API, ingestion proxy, PostgreSQL and Redis — so a complete install
  is one command with nothing to download and nothing to configure:
  docker run -d -p 5101:80 -p 5102:8081 -v proxytrace:/data ghcr.io/proxytrace/proxytrace.
  All state lives in the /data volume; schema migrations still apply on start.
• Images are published to Docker Hub as well. Each release pushes the image to
  proxytrace/proxytrace on Docker Hub and ghcr.io/proxytrace/proxytrace on GHCR — one
  build, identical tags and digests, linux/amd64 + linux/arm64.

Changed

• The release now ships one image instead of three. The separate proxytrace-api,
  proxytrace-proxy and proxytrace-frontend images are no longer published; the all-in-one
  image replaces them. The Docker Compose deployment attached to every release still runs
  PostgreSQL and Redis as their own containers — it points the app at them with
  ConnectionStrings__Default / Redis__ConnectionString, which is what keeps the image's
  embedded database and cache switched off. Upgrading an existing Compose install: take a
  database backup, then swap in the new release's docker-compose.yml — it replaces the three
  app services with one and keeps your pgdata, appdata and searchindex volumes exactly as
  they are, so the database, the secret-encryption key ring and the search index all carry over.

• Errored A/B validations no longer count as disproven theories. When a theory's A/B
  validation cannot run at all (unreachable or unauthorized provider, upstream timeout,
  incomplete run), the theory now settles in a new Failed state instead of Invalidated.
  Failed theories are excluded from the review desk's win rate (an outage is not a lost
  experiment), surface in a new Needs attention queue group with a red could not test
  node on the loop strip instead of disappearing into History, and can be retried from
  their dossier once the underlying problem is fixed (or dismissed). Resubmitting the same
  idea is no longer blocked by a failed prior attempt, and each failure is recorded in the
  audit log (Theory Validation Failed).

Proxytrace 1.5.0

Added

• Ask Tracey everywhere. Context-aware ⚡ Ask Tracey buttons now appear throughout the
  app — on a trace's detail drawer (anomaly-aware: flagged traces ask why did this anomaly
  happen and how do we prevent it, with the detector hits passed along), on an agent's header
  (pass-rate-aware: agents with weak suites ask for an improvement to A/B-test), on a test
  run's header (explain the failures and suggest fixes), on a theory's drawer (walk through the
  proposal and recommend accept/reject), and on the Anomalies and Dashboard pages (project-wide
  investigation / health review). Clicking one jumps to Tracey AI and starts a fresh
  conversation pre-loaded with the entity's context; the previous conversation is kept in the
  history rail.

• Real-time blocking anomaly detectors. A custom anomaly detector can now also block: turn
  on Block matching requests at the proxy and the proxy checks each incoming request's body
  against the detector's phrase/regex triggers before forwarding — on a match the request is
  rejected with an OpenAI-compatible 403 (code: proxytrace_blocked) and never reaches the
  upstream provider. The canonical use case is stopping secrets (e.g. a password pattern) from
  being sent to the LLM provider. Blocked calls still show up as traces, flagged Blocked at
  proxy, with the detector and matched trigger attributed in the trace's anomaly banner, a live
  entry on the Anomaly dashboard, and a notification. Blocking is trigger-match only (the LLM
  review never runs in the request path), applies rule changes within ~30 seconds, fails open if
  the rules cannot be loaded, and — for detectors scoped to specific agents — enforces only when
  the client names its agent via the x-proxytrace-agent header. Part of the Enterprise custom
  anomaly detectors feature.

• Sortable trace table + composable filters. The Traces table can now be sorted by any
  metric column — Latency, Tokens, Tools, Cached, or Time — with a click on the column header
  (click again to flip direction); sorting is server-side, so "slowest call" means across all
  matching traces, not just the visible page. The toolbar's agent dropdown and "Outliers only"
  pill are replaced by a composable + Filter button that sits on the toolbar line beside
  search and the time range: stack removable filter chips for agent, anomaly type (any, or a
  specific reason like high latency or a custom-detector hit), tool name (picked from the tools
  your traces actually called — and once you've picked an agent, only the tools that agent
  used), model, HTTP status class (2xx/4xx/5xx), token/latency ranges,
  and System traces (include traces from system agents — chosen from + Filter instead
  of a separate toggle). Filters combine, the timeline follows them, and
  your chips are remembered per project. Traces captured before this release are indexed
  automatically on upgrade so the tool-name filter covers them too.

• A new Anomaly dashboard. A dedicated Anomalies page (in the sidebar, after Traces) brings
  every agent's anomalies together in one place: a table of recently flagged calls (agent, message
  preview, why it was flagged, when) beside a statistics column — a live, stacked per-agent
  timeline with an agent legend (five-minute, hourly, or daily buckets), summary tiles (flagged
  calls, statistical vs. detector flags, agents affected), and a Most flagged agents ranking
  with proportional share bars. Filter by agent and click any row to open the trace's full detail
  panel right on the dashboard (the same panel as the Traces page, with prev/next stepping through
  the flagged calls). The whole page updates in real time as calls are captured and flagged.

• Custom LLM-based anomaly detectors (Enterprise). Define your own anomaly detectors per
  project: describe what "anomalous" means in plain-language review instructions, pick a review
  model, and set 1–20 trigger words or regular expressions that gate which calls get reviewed. When
  a trigger matches a new turn, the detector's model reviews it and — on an anomalous verdict — flags
  the call with a Custom detector chip, adds it to the Anomaly dashboard, and raises a
  notification that deep-links to the trace. Scope a detector to all agents or selected ones, and
  enable or disable it without losing its configuration. Because reviews cost one model call per
  trigger-matched turn, triggers keep the LLM focused only on the calls that could be a problem.
  Detectors are managed on the dashboard's Detectors tab — a two-column view (like Evaluators)
  with the searchable detector list on the left and the selected detector's instructions, triggers,
  and agent scope on the right, including a quick enable/disable toggle in the detail header.

• Anomalous traces announce themselves in the trace detail panel. Opening a flagged call's
  details — from the Traces list or the Anomaly dashboard — now shows an Anomalous trace
  warning banner right below the header: the statistical reasons as chips (high latency, high
  token count, …) and, for custom-detector hits, the detector's name, the trigger that matched,
  and the reviewer's reasoning.

• Non-LLM upstream endpoints now pass through the proxy. Any path under your project base URL
  that isn't part of the OpenAI API (for example /{project}/health) is transparently forwarded to
  your provider's upstream host instead of returning 404, so clients can reach a provider's health
  check or other endpoints through the same base URL they use for completions. These pass-through
  calls are not captured as traces and still require a valid project API key. Redirect, throttling,
  and caching response headers (Location, Retry-After, Allow, Cache-Control) are relayed,
  and upstream redirects are passed back to the client verbatim instead of being followed
  server-side.

Changed

• Proxytrace is now source-available. The full source code is public at
  github.com/Proxytrace/Proxytrace under the
  Elastic License 2.0: read, build, run, and modify it freely. Providing Proxytrace as a
  managed service to third parties and removing or circumventing the license-key
  functionality are not permitted. Paid tiers keep working exactly as before — unlocked
  with a license key.

• Quick-start now teaches deterministic agent naming. The ingestion quick-start — the
  Traces empty state and the setup wizard's final step — and the proxy setup guide now show
  the optional x-proxytrace-agent header, which attributes calls to the named agent
  directly instead of relying on prompt-similarity matching.

• The dashboard is now a live mission control. A new full-width pulse band charts
  per-minute call activity over the last hour and beats in real time as traces arrive. The
  live trace feed moved to center stage with richer rows (agent identity, live age, arrival
  flash), the token headline grew into an animated gradient display, and queue depth and p95
  latency joined the stat tiles. Charts draw in on load; all motion honors reduced-motion
  preferences. The old telemetry strip's proxy-version label was retired along with the strip
  itself.

• The dashboard's lower half got the mission-control treatment. The old donut, one-bar
  latency histogram, and agent-card grid are replaced by two denser, more honest sections:
  an Agent fleet roster — one row per agent with its own activity sparkline (the top
  pulse band, decomposed per agent), endpoint, token total and fleet share, trace count, and
  last-active time — and a Latency spectrum showing each endpoint's min→max latency span
  on a shared log scale with p50/p95/p99 markers, alongside the project-wide percentile
  strip. The fleet header's proposals chip now shows the real count of pending
  optimization proposals (it was previously a static placeholder) and links to the
  Proposals view.

• The Proposals page is now a review desk. The four-column theory kanban (whose first two
  columns sat empty most of the time) is replaced by a master/detail decision inbox. A queue
  rail groups theories by urgency — Needs decision first, then Awaiting adoption, live
  In flight items, and a collapsed History — and a loop strip across the top shows the
  optimization pipeline at a glance (testing → need decision → awaiting adoption → decided,
  closing with the total proven gain; each node jumps to its group). Selecting an item opens a
  full-width dossier in place of the old drawer: the measured gain and significance lead, the
  proposed change diff finally has room, evidence (A/B results, source runs, rationale) sits
  alongside, and Promote / Dismiss live in a pinned decision bar. Promoted proposals surface
  their handoff package first; validated-but-promoted, adopted, and dismissed items no longer
  masquerade as reviewable.

• The sidebar now follows your workflow. Navigation is regrouped into Monitor
  (Dashboard, Traces, Anomalies), Build (Agents, Agent Playground), and Improve — the
  whole optimization loop in order (Test Suites, Evaluators, Evaluator Playground, Test Runs,
  Proposals), so a proposal and the run that produced it finally live side by side. Tracey AI
  moved to a dedicated slot at the top, and the Audit Log, an admin Settings shortcut,
  and the Documentation link now sit together in a utility area above the project selector.

• Tracey AI chat is easier on the eyes — and looks the part. Chat messages, the composer, and
  in-chat headings now render at a comfortable reading size instead of the app's compact data
  scale, and the whole page picked up an identity: an animated gold-and-teal halo around Tracey's
  avatar (it spins while she's thinking), a soft aurora across the top of the chat panel, a
  gradient-lit wordmark and welcome screen, a shimmering *Thi...

Proxytrace 1.3.0

Added

• Outlier detection for traces. Each ingested call is now flagged when it deviates from its
  agent's own recent behaviour on any of four per-call metrics — high token count (also the cost
  signal), high latency, low turn-2+ cache hit, and many tool calls. Detection is
  per-agent and adaptive: a call is flagged when a metric exceeds the agent's recent mean ± N
  standard deviations, so a cheap fast agent and an expensive reasoner each get their own "normal".
  The Traces list carries a dedicated Anomalies column (just before the timestamp) that shows
  an amber warning chip on each flagged call — hover it for the reasons — plus a new Outliers only
  toggle that filters the list to just the outliers, and the agent detail page gains a Recent outliers widget
  that lists why each recent call was flagged. Admins tune the sensitivity (enable/disable, sigma,
  minimum samples, baseline window) under Settings → Outlier detection. Existing traces are not
  retroactively flagged; detection applies to calls ingested from now on.
• Call distribution stats on the agent page. The agent detail view's Performance card now
  shows one small card per stat in a single grid that reflows to the available width: the window
  totals (pass rate, traces, tokens, cost, latency — each with a trend sparkline), then the
  mean ± standard deviation of an agent's successful calls over the selected range — input and
  output tokens and latency (per call), and cost, cache hit rate (turns after the
  first, which can't be cache hits) and tool calls (per conversation). Each distribution card draws
  a small density curve of the real sample shape — hover to read a slice's value range and how many
  calls (or conversations) fall in it — and metrics with no signal in the window (an agent that never
  caches or calls a tool) are dropped rather than shown empty. Everything shares one time-range selector
  that persists as you switch agents, and updates live as new traces arrive, so a single card shows
  not just the totals but how consistent — or skewed — your agent's calls are.
• Sample a test run multiple times. When you start a run you can now pick a sample count (1–5) —
  Proxytrace runs each selected endpoint that many times and averages the results per endpoint, so
  non-deterministic models don't hide flaky cases. The results matrix shows one column per endpoint with
  a per-case pass fraction (e.g. 4/5) and average score, a new Flaky filter surfaces cases whose
  samples disagree, and clicking a cell drills into the individual sample i/N runs. Anomaly detection
  and the auto-optimization loop operate on one representative run per endpoint, so sampling never
  fires duplicate anomalies or biases a proposal toward a single lucky sample. Existing single-sample
  runs look exactly as before.
• Two-factor authentication (TOTP). Protect your account with a second factor from an
  authenticator app (Google Authenticator, Authy, 1Password). Turn it on under Account security
  (in the account menu): scan the QR code, confirm a code, and save the 10 one-time backup codes
  you're shown. After that, signing in asks for a 6-digit code — or a backup code if you've lost your
  device. Disabling it requires your password. Admins can clear a locked-out user's MFA from
  Settings → Users (Reset MFA). MFA is opt-in per user, free on every tier, and applies to
  password (local) sign-in; SSO/OIDC handles MFA at your identity provider. Enabling, disabling, and
  failed code attempts are recorded in the audit log, and the verification endpoint is rate-limited.
• Forgot your password? Self-service reset. The sign-in screen now has a Forgot password?
  link. Enter your email and Proxytrace sends a one-time reset link — valid for 1 hour — that lets you
  choose a new password and signs you straight in. No SMTP? You're still covered: if outgoing
  email isn't configured, the reset link is written to the server log for the operator to relay, and
  an admin can mint a one-time reset link for any user from Settings → Users (the Reset
  password button). Reset requests and completions are recorded in the audit log, and the public
  reset endpoints are rate-limited.
• Cancel or reject an optimization theory. On the Optimization Theories board you can now
  dismiss a theory you don't want to pursue: Reject a Proposed theory to skip A/B validation
  entirely, or Cancel validation on a Validating theory to abort its in-flight A/B run. Either
  way the theory moves to Rejected and can still be reset later. Validation already runs one
  theory at a time, so these controls let you clear the queue and stop runs you no longer need.
• Much broader audit-log coverage. The audit log now records far more of what happens in
  Proxytrace: the whole optimization-theory loop (theory submitted/reset/rejected, plus the A/B
  pipeline's validated/invalidated decisions, the proposals it generates, and proposals it
  auto-adopts), the test-run lifecycle (cancel, optimize, delete) and recurring schedules
  (create/update/delete/run-now), trace deletions, agent-version moves, test-case edits, the
  destructive non-model data purge, and the one-time at-rest secrets backfill. New OIDC coverage: the first-time
  provisioning of an SSO user is now recorded. New failure visibility: a forbidden attempt to
  change something (HTTP 403) is logged as an Access denied failure, so privilege-probing shows up
  alongside failed sign-ins. All new action types are filterable on the audit-log page.

Changed

• The Evaluators page remembers your selected time range. The range selector (1h / 24h / 7d /
  30d) on the evaluator detail now persists, so it survives switching between evaluators and reloading
  the page instead of snapping back to 7d each time (matching the agent detail page).

• Consistent typography, spacing and corners across the app. Swept every screen onto the design
  system's type scale, spacing steps, corner radii and surface colours, replacing dozens of off-scale
  one-offs that left labels, paddings and rounded corners subtly mismatched between otherwise-identical
  panels. Purely visual — no behaviour changes.

• Live duration, cost and tokens during a test run. While a run is in progress its model cards now
  count duration, cost and tokens up as each case lands, instead of sitting at "—"/$0 until the
  run finished. Running runs are also highlighted in the left-hand Test Runs list with an animated
  accent ring and a pulsing Running tag, so an in-flight run is obvious at a glance.

• The Test Runs list loads incrementally. Instead of fetching a large batch up front, the runs rail
  now loads the most recent runs first and reveals older ones on demand via a Load more button —
  faster to open and lighter on projects with a long run history.

• Test-run model comparison, rebuilt around your production model. A run's results now open with
  the model you have in production (the agent's deployed endpoint) as the baseline — a
  highlighted champion card carrying the headline pass rate plus duration, cost, and token totals.
  Every other model is a candidate, read as deltas measured against production: pass-rate
  points, faster/slower, and cheaper/pricier, coloured green when the candidate wins that metric and
  red when it loses — so it's obvious at a glance whether a candidate is worth switching to. Three
  award medals call out the highest pass rate, the fastest, and the cheapest model, and the
  evaluator breakdown now highlights the leading model per evaluator. When a run doesn't include your
  deployed model, the best performer stands in as the baseline. Deltas and medals still appear only
  once the whole run group has finished.

• Tracey no longer cuts a reply short at a turn limit. The assistant's per-turn tool-step cap and
  its "Step limit reached" notice have been removed, so a complex request that needs many tool steps
  now runs to completion instead of stopping early and asking you to continue. (A high internal
  safety backstop still prevents a runaway loop.)

• Tracey's per-response stats now break down token usage. The quiet status row beneath each reply
  shows input tokens, the share of input served from cache, and output tokens instead of
  a single total — making it clear how much of a turn's cost was cached prompt vs. fresh input vs.
  generated output.

• Tracey now focuses on your own agents. Her data tools hide Proxytrace's internal system
  agents — Tracey herself and the evaluators that score your test runs — by default, so "list my
  agents", token-usage charts, recent test runs (the internal A/B validation runs are hidden too),
  and trace searches stay about your work rather than the platform's own activity. Ask explicitly
  (e.g. "include the Tracey agent" or "list system agents") and she'll add them back in.

Fixed

• Evaluator statistics now include historical evaluations. The Evaluators page (average score,
  evaluation count, pass rate, average latency, score distribution and the per-evaluator sparkline)
  reads a query-optimized projection that was only written for evaluations recorded after the feature
  shipped — so existing results showed a dash or zero even when an evaluator had plenty of past
  evaluations. A one-time, idempotent backfill now rebuilds that projection for older results on
  startup, so historical evaluations count toward the statistics.
• Test-run latency now measures the model, not the wall clock. The latency shown on a run's
  per-model comparison cards (the champion card, the candidate "Speed" deltas, and the "Fastest"
  medal) and on an optimization proposal's A/B-test card was computed as a wall-clock timer...

Proxytrace 1.2.0

Added

• Offline-only licenses for air-gapped installs. Proxytrace now recognises license keys issued
  as offline-only: they are verified entirely on the box (signature + expiry) and are never
  checked against the license server, so an install with no outbound internet keeps running without
  hitting the offline grace window. Such a key cannot be revoked and works until its built-in expiry
  (capped at 365 days), at which point the installation downgrades to Free. Settings → License
  shows an "offline license" note and hides Re-check now for these keys. Normal (online) keys are
  unchanged — still re-checked every 24 hours and revocable.

Proxytrace 1.1.0

Added

• Secrets are now protected at rest. Upstream provider API keys are encrypted in the database
  (recovered only to call the provider), while inbound Proxytrace API keys and invite tokens are
  stored as one-way hashes. As a result, a newly generated API key and a new invite link are now
  shown once, at creation — copy them then; afterwards the key list shows only a short,
  non-secret prefix to identify each key. Existing keys, provider credentials, and pending invites
  are protected automatically on upgrade, with no action required and no disruption to live
  integrations.

• Email notifications. Operators can configure outgoing SMTP under Settings → Email notifications, including an instance-wide minimum severity (default Warning, so members are emailed warnings and critical alerts by default). Users can opt in to receive notification alerts by email, choosing All, Critical, or None from the account menu (defaulting to All). The SMTP password is encrypted at rest using ASP.NET Data Protection.

• Audit log of system actions. Proxytrace now keeps a durable, user-attributed record of
  significant actions — authentication events (sign-in, failed sign-in, sign-out, first-admin setup,
  legacy-account claim), user invites/sign-ups/role changes/deletions, project create/rename/delete
  and membership changes, agent endpoint changes and deletions, test-suite / test-case / evaluator
  creation, update and deletion, test runs started (manual, scheduled, or via MCP), optimization
  proposal status changes, API keys minted and deleted, provider/endpoint configuration changes, and
  license changes. Each entry captures who performed it (the signed-in user, the owner of the API
  key used, or the system for scheduled work), what was acted on, and when — and entries are
  kept even after the thing they refer to is deleted. Admins see the full trail under
  Settings → Audit log; project members see their own project's trail (but not instance-wide
  actions). The log is lossless and retained for 365 days by default.

• Cached-input tokens are now tracked and priced separately. Many providers serve part of a
  prompt from their cache at a much lower rate. Proxytrace now captures how many of each call's input
  tokens were cache-served (from both the ingestion proxy and Playground/test-run/evaluator calls),
  fetches the cheaper cached-input price from the model-price catalog alongside the input/output
  prices, and factors it into every cost estimate — so the numbers reflect what you actually pay. A
  muted "(N% cached)" hint now appears next to the input-token figures across Traces, the
  dashboard, the Playground, agent and run summaries, and the LLM-judge cost panels. Calls with no
  cached price keep costing exactly as before.

• Connect external AI agents over MCP. Proxytrace now hosts a built-in
  Model Context Protocol server at /mcp, so external agents
  (Claude Desktop, Cursor, your own scripts) can use Proxytrace the way the built-in Tracey assistant
  does — listing and reading agents, traces, suites, runs, proposals and statistics, curating suites
  from captured traces, starting test runs, analysing run failures, and submitting A/B-tested
  optimization theories. It also ships guided workflows (MCP prompts an agent surfaces as slash
  commands — optimize_agent, curate_suite, run_tests, review_proposals, project_insights)
  that walk an external agent through the same playbooks the built-in Tracey assistant uses. It
  authenticates with a Proxytrace API key (minted
  on the Providers page): the key's project becomes the agent's working context. API keys now carry
  explicit capabilities — Ingestion proxy, MCP read, MCP write — chosen when the key is
  created, so an agent key can be made read-only and a proxy key can't drive MCP (least privilege).
  Each key also has an owner (a user, chosen at creation): every MCP call is attributed to that
  user. See the MCP Server guide for client setup and the full tool list.

• Multilingual UI with per-user language. Proxytrace can now display its interface in multiple
  languages, starting with German alongside English. Each user picks their own language from a
  grouped Language section in the account menu (top-right) — each option shown with its country
  flag — and the choice is saved to their account so it follows them across devices and browsers. Technical terms that AI engineers expect in English — Tool, User, Assistant,
  Trace, Token, Prompt, Agent, and the like — are deliberately kept untranslated. English remains the
  source language, and new translations are produced by an audience-aware translation tool, so more
  languages can be added without code changes.

• Stop Tracey mid-reply. While Tracey is thinking or replying, her send button now becomes a
  Stop button — pressing it cancels the response. The in-flight model call is torn down (not left
  running in the background), so a long or off-track answer can be halted immediately. If she was
  waiting on a long-running action you started (a test run or optimization theory), stopping only ends
  her wait — that action keeps running on the server and its result still lands on the Runs/Proposals
  page.

• Jump from an error toast to the captured error. When a backend request fails, the red error
  toast is now clickable for admins — selecting it opens the Error Log with that exact error
  already selected, so you go straight from "something broke" to its full stacktrace. The toast
  carries the captured error's id; non-admins (who can't see the Error Log) get the plain,
  non-clickable toast as before.

• Notifications inbox in the top bar. A new bell icon in the top bar — with an unread badge —
  opens a notifications inbox available on every page. It surfaces negative anomalies detected after
  each test run — a run that failed (e.g. the endpoint was unavailable), a drastic pass-rate
  drop, or a strong latency increase versus the suite's recent baseline. Alerts arrive live (no
  refresh), are colour-coded by severity, deep-link to the affected run, and can be marked read or
  dismissed; an unread count shows at a glance. The inbox is multi-purpose by design: the same surface
  will carry other notification kinds (such as a ready optimization proposal) and, in a future
  release, additional delivery channels like email.

• A suite's run history at a glance. The suite detail panel has a new History tab listing
  that suite's previous runs (newest first, with per-model pass rates); clicking a run opens it on
  the Runs page. The history is fetched suite-scoped, so it isn't diluted by other suites on the same
  agent. The header's run button is now simply labelled Run.

• Periodic test-run scheduling (Enterprise). Test suites can now be run automatically on a
  recurring schedule against a fixed set of model endpoints. Pick a frequency — hourly at a
  chosen minute, daily or weekly at a chosen time of day (UTC), or a custom every-N
  minutes/hours/days interval — and the dialog previews the exact next execution date/time as
  you choose. Schedules are managed from the new Scheduled tab on the Runs page — create, edit,
  pause/resume, and run-now — and each schedule card shows its cadence, the next run's date/time, and
  a summary of its most recent runs. Scheduled runs feed the optimization loop exactly like manual
  ones. Creating and managing schedules requires an Enterprise license; existing schedules stay
  listable after a downgrade but stop running until re-licensed. You can also create and manage a
  suite's schedules directly from its detail panel on the Suites page.

• The Traces page empty state now shows how to ingest. Instead of only a link to the manual,
  an empty Traces view displays the project's actual OpenAI base_url and a copy-paste quick-start
  snippet (Python / TypeScript / C# / curl), so you can wire up the proxy without leaving the page.
  A filtered-but-empty view shows a distinct "no match" hint instead.

• The manual's Proxy Setup page now shows your instance's real endpoint. When the manual is
  read from a running Proxytrace instance (served at /docs), the OpenAI base_url box fills in
  the operator's actually configured proxy host instead of a placeholder, and a clearer "what the
  proxy endpoint is" section explains where to copy the ready-to-use endpoint in the app.

• Tracey can now curate test suites from traces. The in-app AI assistant can build a new test
  suite for an agent from captured traces, add traces to an existing suite as test cases, set a
  case's expected output, and remove cases — closing the curate→benchmark→run loop entirely in
  chat. She can also cancel an in-progress test run. All are confirmation-gated writes.

Changed

• Tracey shows cards on demand instead of one per tool call. A multi-step answer used to stack
  a full card for every lookup Tracey did on the way to the result. Now Tracey decides what's worth
  showing: the reads she does for her own reasoning collapse to a quiet, expandable one-line trace,
  and a full card appears only when that card is the answer you asked to see. Charts, tables, the
  entity you asked about, live test-run/optimization cards, and confirmations still render in full —
  the change only quiets the intermediate lookups, so the thread reads cleaner.

• A suite now runs against at most three model endpoints at once. Both manual runs and
  scheduled runs are capped at three endpoints per run, so a model comparison stays focused (and
  bounded in cost). Endpoints are now picked from a searchable multi-select (replacing the old
  stacked checkbox list, which scaled poorly with many models) — type to filter, selected models
  show as chips...

Proxytrace 1.0.3

Added

• "How to wire the proxy?" documentation link on the Traces page empty state.

Changed

• The Tracey AI assistant is now an Enterprise feature. On the Free tier the sidebar
  entry is locked and the Tracey page shows an upgrade prompt; the Tracey API endpoints
  respond with HTTP 402.

Fixed

• Upgrade/pricing links (upgrade placeholder, upgrade dialog, docs) pointed at
  proxytrace.dev/pricing instead of the correct proxytrace.dev/#pricing anchor.

• The ingestion endpoint shown in the setup wizard and on the API-keys page pointed at the
  web UI port instead of the ingestion proxy (e.g. :5101 instead of :5102 in the Docker
  deployment), where OpenAI calls fail with 405 Not Allowed. The backend now advertises
  the proxy's public URL (Proxy:PublicBaseUrl; in Docker PROXYTRACE_PROXY_PUBLIC_URL,
  default http://localhost:5102) and the UI displays that.

Proxytrace 1.0.0

First stable release.