Your agent → your collector → one pipeline7 products1 Private betaStation SouthBase

Observability that explains

Know why your agent failed — and trust the measurement that said it did. Tracing is a solved problem; OpenTelemetry commoditised it. The unsolved problems are whether an agent's output was actually good, and — when it wasn't — which step caused it.

SouthBase is pre-launch. The platform is in private beta with design partners and there is no self-signup yet. Every product page states exactly where that product stands.

Speaks OpenTelemetryYOUR TRACES ARE YOURS

  • OpenTelemetryThe wire format. Instrumentation that points here points at any OTLP backend.
  • OpenInferenceThe semantic conventions for LLM spans, so a trace means the same thing everywhere.
  • OTLP / HTTPThe transport. No proprietary SDK to adopt and no custom protocol to reverse.
  • Apache-2.0The collector runs in your infrastructure, and you can read the code that redacts your payloads.
THE PATHREDACTION AT THE BOUNDARY

Your application, your collector, one pipeline. Redaction happens before anything crosses the boundary — which is the only promise about your data we can make structurally rather than contractually.

  1. 01

    Your application

    Emits OpenTelemetry spans through an OpenInference instrumentor. No proprietary SDK.

    OTLP
  2. 02

    The SouthBase agent

    An Apache-2.0 OpenTelemetry Collector distribution running in your own infrastructure. Redacts fields, normalises tokens into four buckets, attaches cost.

    Apache-2.0
  3. 03

    Ingest and enrich

    Spans land blob-first, then a worker computes cost against a versioned price book and writes the result with the version that produced it.

    OTLP/HTTP
  4. 04

    Seven surfaces

    One pipeline feeds observability, evaluation, governance and the security products — rather than four agents and four bills.

    one pipeline
Runs in your infrastructureRuns in SouthBase cloud

The loopTHREE JOBS · ONE PIPELINE

Three jobs. Most tools in this category only do the first.

Everyone converged on tracing. Almost no one solved trustworthy evaluation or failure attribution — and those are the two that tell you what to fix. Here is where each of the three actually stands.

01

Watch

A trace that survives a ten-minute run

Span trees are the right shape for a request and the wrong shape for an agent run with fifteen tool calls and sub-agents. The transcript reads in order, start to finish, with the hierarchy a toggle away.

Private betaLLM Observability

  1. agent.run
  2. llm.plan
  3. retriever.query
  4. agent.step
  5. llm.call
  6. tool.execute
  7. llm.call
  8. memory.write
  9. llm.synthesize
Schematic. The nesting and order of spans in one agent run — not a capture, and deliberately carrying no durations or token counts.

02

Judge

A judge you can calibrate, not just more metrics

LLM-as-judge is widely distrusted for documented reasons — position bias, verbosity bias, self-enhancement bias, poor correlation with human raters. More metrics do not fix that. Measuring the judge against human labels and publishing the interval does.

In developmentLLM Evaluation

HUMAN LABELJUDGE SCORE
Schematic, with no values on either axis. A judge worth trusting sits on the diagonal, and publishes the width of the band around it.

03

Attribute

Which step actually caused the failure

When a multi-agent run fails, the best tools give you a trace and one black-box score. They cannot say whether planning, retrieval, synthesis, a tool call or a memory write caused it. The literature calls credit assignment underdeveloped, and it is.

In developmentLLM Evaluation

  1. llm.planClean

    Decomposed the request into four sub-tasks.

  2. retriever.queryAttributed cause

    Returned a passage that no longer matched the source document.

  3. llm.callDownstream of the cause

    Reasoned correctly over the passage it was given.

  4. llm.synthesizeDownstream of the cause

    Produced a confident answer grounded in the stale passage.

Schematic. Three of these four steps did their job correctly — which is exactly why a single run-level score cannot tell you what to fix.

The platform7 PRODUCTS

Seven products, one pipeline

The same instrumented traces answer four different kinds of question — did it work, was it good, was it allowed, and is it secure. Building those on one pipeline is the point; it is also why the list is longer than what ships today.

What actually works today1 Private beta

The honest version

A roadmap is not a product. Here is the part that exists and runs, so you can judge us on it rather than on the list above.

  • Four-bucket Claude cost

    Input, output, cache creation and cache read are billed at four different rates. A tool reporting two cannot tell you what a request cost. Take a real shape from our conformance fixtures — 500 fresh input tokens, 220 output, 40,000 cache reads. A two-bucket tool reports “40,500 input tokens”, which is arithmetically true and completely useless.

    cache_read / (input + cache_creation + cache_read) = 0.988

    That is the cache-hit ratio, and it is the number that tells you prompt caching is working. How the four buckets work →

  • A transcript, not just a span tree

    Span trees are the right shape for a request and the wrong shape for a ten-minute agent run with fifteen tool calls and sub-agents. The transcript reads in order, start to finish, with a span-tree toggle when you want the hierarchy back.

  • A replay button

    Capture enough of a run — prompt, params, model, tool inputs and outputs, retrieved context — to re-run it and diff the result against the original. It is the most frequently requested feature in this category and one of the simplest to actually use.

  • An agent you can read

    The collector is Apache-2.0 and runs in your infrastructure. Redaction happens there, so sensitive payloads never reach us — and you can read the code that does it rather than take our word for it.

    The agent on GitHub →

Private betaRunning with design partners. Not open for self-signup yet.

On lock-in

Leaving should cost a config change

The wire format is OpenTelemetry, so the instrumentation that points at SouthBase points at any other OTLP backend. That is deliberate, and it is worth being precise about why: we are a hosted, proprietary platform, so “your data is portable” is a promise we should have to demonstrate rather than assert. Using a neutral wire format is how it gets demonstrated.


Send one trace and check the cost yourself

The quickest way to judge this is arithmetic: run a cache-heavy Claude workload through it and see whether the number matches your Anthropic console. That is the bar we set for ourselves — and design partners are how it gets tested against real traffic.