# See what needs to be fixed in your AI agent

Latitude traces every step your agent takes — every tool call, every reasoning turn — so when something breaks, you know exactly where in the chain it went wrong.

Under

#### 10 minutes
to full agent trace visibility

Save up to

#### 80% of time
going through logs manually

# Most observability tools are built for APIs, not agents. Latitude is different.

Other observability tools tell you something failed. Latitude tells you where in the chain, and why.

# Multi-step traces

See where in the chain your agent went wrong, not just what it returned

# Tool call visibility

Know exactly which tool was called, with what input, and what it returned

# Reasoning observability

Follow your agent's decision path turn by turn

Observability

Failure detection

Issue monitoring

## Observability

Capture real inputs, outputs, and context from live traffic. Understand what your system is actually doing, not what you expect it to do.

#### Full traces

Observe your AI’s behaviour in the most comprehensive way

#### Usage statistics

Keep track of the token usage and regulate expenses

Observe

# Monitor agent behaviour

Capture real inputs, outputs, and context from live traffic to understand what your agent is actually doing

Annotate

# Flag what went wrong

Review real agent responses and annotate where things went off. That signal is what drives everything next.. Turn intent into a signal the system can learn from.

Reflect

# See what keeps going wrong

Automatically group failures into recurring issues, detect common failure modes and keep an eye on escalating issues.

# Start with visibility

# Start with visibility. Grow into reliability.

Start the reliability loop with lightweight instrumentation. Go deeper when you’re ready.

Providers

- OpenAI
- Anthropic
- Azure
- Google AI Platform
- Amazon Bedrock
- Cohere
- Together AI
- Vertex AI
- Gemini
- Groq
- Mistral AI
- Ollama
- LiteLLM
- Replicate
- AWS SageMaker
- Hugging Face Transformers
- Aleph Aplha
- IBM watsonx.ai

```javascript
import { LatitudeTelemetry } from '@latitude-data/telemetry'
import OpenAI from 'openai'

const telemetry = new LatitudeTelemetry(
  process.env.LATITUDE_API_KEY,
  { instrumentations: { openai: OpenAI } }
)

async function generateSupportReply(input: string) {
  return telemetry.capture(
    {
      projectId: 123, // The ID of your project in Latitude
      path: 'generate-support-reply', // Add a path to identify this prompt in Latitude
    },
    async () => {
      const client = new OpenAI()
      const completion = await client.chat.completions.create({
        model: 'gpt-4o',
        messages: [{ role: 'user', content: input }],
      })
      return completion.choices[0].message.content
    }
  )
}
```

#### Instrument once

Add OTEL-compatible telemetry to your existing LLM calls to capture prompts, inputs, outputs, and context.

This gets the loop running and gives you visibility from day one

#### Learn from production

Review traces, add feedback, and uncover failure patterns as your system runs.

Steps 1–4 of the loop work out of the box

#### Go further when it matters

Use Latitude as the source of truth for your prompts to enable automatic optimization and close the loop.

The full reliability loop, when you’re ready

# Integrations

# Integrates with your stack

Latitude is compatible with the majority of the platforms used to build LLM systems

- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
-

# FAQ

Asnwer to the most popular questions

What's the difference between LLM observability and regular logging?

Do I need observability if my LLM app is already working fine?

How is Latitude different from Langfuse or other observability tools?

How quickly can I see my first production traces?

What issues will observability actually help me catch?

We're already using OpenAI's dashboard. Why do I need more?

Once I can see issues, then what?

Is there a free trial?