The Agent Stack #025 — Monday Build

Distributed tracing just got its AI moment. Jaeger v2 dropped with OpenTelemetry at its core, specifically targeting the chaos of multi-agent workflows.

The timing isn’t coincidental. Traditional observability breaks down when you have agents calling other agents calling APIs calling more agents. You end up with a mess of logs that tell you nothing about why your agent decided to delete the production database (yes, that actually happened this week).

Building observable agent workflows

Here’s what changes with Jaeger v2. Instead of piecing together disparate logs, you get unified traces across your entire agent stack.

The key is the OpenTelemetry integration. Every agent action becomes a span. Every tool call, every reasoning step, every API request gets captured in a single trace tree.

from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Set up Jaeger v2 tracing
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

jaeger_exporter = JaegerExporter(
    agent_host_name="localhost",
    agent_port=6831,
)

span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Instrument your agent
class TraceableAgent:
    def __init__(self):
        self.tracer = trace.get_tracer(__name__)
    
    def execute_task(self, task):
        with self.tracer.start_as_current_span("agent.execute_task") as span:
            span.set_attribute("task.type", task.type)
            span.set_attribute("agent.id", self.agent_id)
            
            # Trace the reasoning step
            with self.tracer.start_as_current_span("agent.reasoning") as reasoning_span:
                plan = self.reason_about_task(task)
                reasoning_span.set_attribute("plan.steps", len(plan.steps))
            
            # Trace tool usage
            for step in plan.steps:
                with self.tracer.start_as_current_span(f"tool.{step.tool_name}") as tool_span:
                    tool_span.set_attribute("tool.input", str(step.input))
                    result = self.execute_tool(step)
                    tool_span.set_attribute("tool.success", result.success)

The real power comes from span relationships. When Agent A delegates to Agent B, you see the complete call chain. When Agent B uses a tool that triggers Agent C, it’s all connected.

Setting up the new architecture

Jaeger v2 uses a different storage model. Instead of Cassandra or Elasticsearch, it’s built around OpenTelemetry’s OTLP protocol from day one.

Your docker-compose.yml becomes cleaner:

version: '3.8'
services:
  jaeger:
    image: jaegertracing/jaeger:2.0
    environment:
      - COLLECTOR_OTLP_ENABLED=true
    ports:
      - "16686:16686"  # UI
      - "4317:4317"    # OTLP gRPC
      - "4318:4318"    # OTLP HTTP
  
  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ["--config=/etc/otel-collector-config.yaml"]
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    depends_on:
      - jaeger

The collector config handles the heavy lifting:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  jaeger:
    endpoint: jaeger:14250
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [jaeger]

Now every agent in your system sends traces to the collector, which forwards them to Jaeger. You get a single view of multi-agent conversations that actually makes sense.

The upgrade from v1 is straightforward if you’re already using OpenTelemetry. If not, this is your excuse to finally instrument properly.

Quick Hits

  • Memory management tools: Both Memweave CLI and MiniVecDb launched this week for searching agent memory. Memweave focuses on CLI access, MiniVecDb adds garbage collection.

  • Token optimisation: The 8v CLI claims 66% token reduction for agent interactions. Worth testing if you’re hitting rate limits on multi-agent workflows.

  • Agent marketplace: Anthropic’s experiment with agent-to-agent commerce shows where we’re heading. Agents buying and selling real goods autonomously.

One Thing to Try

Set up Jaeger v2 with a simple two-agent system this week. Create one agent that delegates to another, instrument both with OpenTelemetry, and watch the traces flow through. You’ll immediately see bottlenecks you didn’t know existed.

The best debugging tool for AI agents just got a major upgrade. Time to use it.