Skip to content
Comet logo
  • Comet logo
  • Opik
    • LLM Observability & Evaluation
    • Cost Intelligence
    • Agent Optimizer
    • Opik User Stories
    • Compare Platforms
  • Products
    • Opik
    • Cost Intelligence
    • Experiment Management
  • Docs
    • Opik
    • Cost Intelligence
    • Experiment Management
  • Pricing
  • Community
    • GitHub
    • Events
    • Opik User Stories
    • Comet Case Studies
    • Deep Learning Weekly
    • Blog
  • Company
    • Contact Sales
    • Partners
    • News
    • About Us
    • Careers
  • Login
Get Demo
Try Opik Free
Comet logo
  • Comet logo
    • LLM Observability & Evaluation
    • Cost Intelligence
    • Agent Optimizer
    • Opik User Stories
    • Compare Platforms
    • Opik
    • Cost Intelligence
    • Experiment Management
    • Opik
    • Cost Intelligence
    • Experiment Management
  • Pricing
    • GitHub
    • Events
    • Opik User Stories
    • Comet Case Studies
    • Deep Learning Weekly
    • Blog
    • Contact Sales
    • Partners
    • News
    • About Us
    • Careers
  • Login
Get Demo
Try Opik Free

Log In

Try Comet Free
Get A Demo
Get Demo
Try Opik Free
OSS version23.4K
Free cloud version: Try Opik

The Fastest Path to Agents That Work

Opik connects observability to action, automatically turning trace data and eval results into code fixes. Your agent keeps evolving and doesn’t make the same mistake twice.

opik community

23,000+

GitHub Stars

developer adoption

150,000+

Users

active organizations

10,000+

Teams

Opik experiment comparing a production candidate against a test suite, with pass and fail results per test case

Trusted by the most innovative AI teams

Assembly AI logo
NatWest logo
Uber logo
Netflix logo
Etsy logo
Stability.ai logo
Mobileye logo
Autodesk logo
Zencoder logo
Stellantis logo

Agent Tracing

Traces give you total LLM observability to visualize and understand what’s happening across complex agentic systems.

  • Trace context retrieval, tool selection, user feedback scores, and more
  • Instrument easily with 60+ integrations
  • Available via MCP and coding agent skills
Try Opik Free
Opik Logs view listing agent conversation threads with message counts, duration, tokens and cost

Automated Debugging

Automatically surface errors from thousands of traces with Diagnostics, using Opik’s MCP server.

  • Detects and groups similar recurring issues
  • Identifies their root causes and recommends fixes
  • Works even when there is no explicit error message
Try Opik Free
Opik Diagnostics view showing a recurring tool error, its summary, an Ollie fix and affected traces

AI Trace Analysis

The Ollie agent lives inside Opik, understands your traces, and recommends and validates code fixes.

  • Ollie determines which step(s) in your system are causing issues
  • Grab and implement a fix then mark the issue Resolved
  • Ollie builds a library of test cases so the same issue doesn’t happen again
Try Opik Free
Ollie, the Opik agent, analyzing a diagnosed tool error and proposing a code fix

Agent Evaluation

Understand your agent’s performance by scoring sets of traces against specific goals.

  • Write assertions and get simple pass/fail results with Test Suites
  • Create datasets and run evals with 40+ LLM-as-a-judge metrics
  • Works with traces from development and production
Try Opik Free
Opik Test Suite results showing a failed run with 2 of 3 natural-language assertions passed

Production Monitoring

Extend observability and evaluation across your agent’s production footprint to help meet governance requirements, track model costs, and ensure consistent performance.

  • Automatically score production traces with online evals
  • Set guardrails and alerts to detect and block violations in real time
  • Monitor cost, latency, and performance at a glance with production dashboards
Try Opik Free
Opik dashboard showing trace count, errors, latency, cost and trace volume charts
Opik Logs view listing agent conversation threads with message counts, duration, tokens and cost
Opik Diagnostics view showing a recurring tool error, its summary, an Ollie fix and affected traces
Ollie, the Opik agent, analyzing a diagnosed tool error and proposing a code fix
Opik Test Suite results showing a failed run with 2 of 3 natural-language assertions passed
Opik dashboard showing trace count, errors, latency, cost and trace volume charts

An End-to-End AI Evaluation Platform

Comet’s end-to-end model evaluation platform for developers focuses on shipping AI features, including open-source LLM observability, application testing and optimization, and coding agent cost tracking.

Comet experiment comparison showing two experiments’ outputs and feedback scores side by side

Opik: Log & Evaluate Your Application’s LLM Calls

Opik provides comprehensive LLM observability so you can confidently test, debug, and monitor your GenAI apps and agents, from application-level unit testing down to individual system prompts and user inputs.

Learn more about Opik
Opik trace output with correctness, hallucination and custom feedback scores

Opik: Optimize Prompts & Agentic Systems

With your application’s LLM calls and responses logged, you can bring in expert reviewers for annotation, score using built-in eval metrics, and even automate prompt engineering for complex multi-step agents.

Prompt Optimization
Opik Cost Intelligence breakdown of coding agent spend by context source, harness and output type

Cost Intelligence: Track & Optimize Coding Agent Spend

Get full visibility into engineering teams’ Claude Code and Codex usage with Cost Intelligence in Opik. Eliminate wasted tokens and gain efficiency across MCP installs, skills, model selection, context retrieval, and configurations.

Cost Intelligence
Validation loss by step chart comparing several model training runs

MLOps: Track & Compare Model Training Runs

Comet Experiment Management gives you the tools to ensure your models are explainable and reproducible, with custom visualizations, model versioning, dataset management, production monitoring, and more.

Experiment Management
Learn more about Opik

Proven Comet Platform Performance

Not all AI observability and evaluation platforms are built the same. Opik is both truly open source, and powered by Comet’s enterprise-grade infrastructure for reliable, trustworthy performance at scale.

Log Thousands of LLM Traces, Fast

Traces appear in the Opik platform ready for debugging almost instantly — even at high volumes.

Enterprise-Grade Reliability & Security

Opik is backed by the Comet platform and built to the standards of the world’s largest organizations.

Flexible Hosting & Deployment Options

Self-host the OSS version, try Opik in the cloud, or talk to us about custom deployment options.

Trilogy logo

“After surveying the landscape and examining the top options, Opik stands out as the preferred LLM evaluation framework. It demonstrated dramatically faster performance in benchmarks, offers a rich feature set, and is built with developer usability in mind.”

Leonardo Gonzalez
VP, AI Center of Excellence

Github

The Opik Difference: Open Source

AI observability should be something you can grab and add to your agent project in an afternoon, without committing to a proprietary stack or going through a long procurement process. That’s why the AI developer community loves open-source Opik.

23.4k

GitHub Stars

Join our growing developer community

60+

Integrations

Easily instrument any AI stack

182

thiagohora
andriidudar
jverre
alexkuzmik
awkoy

Contributors

Available via MCP & Coding Agent Skills

Use Opik where you already work

8.6k

PRs Closed Since 2023

Continuous iteration & improvement

60+ Integrations

Easy Integration

Add just a few lines of code to your project and automatically start tracking LLM app and agent activity with Opik, or code, hyperparameters, model predictions, and more with Comet’s MLOps platform.

Opik LLM Evaluation
from opik import track

@track
def llm_chain(user_question):
    context = get_context(user_question)
    response = call_llm(user_question, context)
    
    return response

@track
def get_context(user_question):
    # Logic that fetches the context, hard coded here
    return ["The dog chased the cat.", "The cat was called Luky."]

@track
def call_llm(user_question, context):
    # LLM call, can be combined with any Opik integration
    return "The dog chased the cat Luky."

response = llm_chain("What did the dog do ?")
print(response)
from llama_index.core import VectorStoreIndex, global_handler, set_global_handler
from llama_index.core.schema import TextNode

# Configure the Opik integration
set_global_handler("opik")
opik_callback_handler = global_handler


node1 = TextNode(text="The cat sat on the mat.", id_="1")
node2 = TextNode(text="The dog chased the cat.", id_="2")

index = VectorStoreIndex([node1, node2])

# Create a LlamaIndex query engine
query_engine = index.as_query_engine()

# Query the documents
response = query_engine.query("What did the dog do ?")
print(response)
from langchain_openai import ChatOpenAI
from opik.integrations.langchain import OpikTracer

# Initialize the tracer
opik_tracer = OpikTracer()

# Create the LLM Chain using LangChain
llm = ChatOpenAI(temperature=0)

# Configure the Opik integration
llm = llm.with_config({"callbacks": [opik_tracer]})

llm.invoke("Hello, how are you?")
from openai import OpenAI
from opik.integrations.openai import track_openai

openai_client = OpenAI()
openai_client = track_openai(openai_client)

response = openai_client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "Hello, world!"}
    ]
)
ML Experiment Management
from comet_ml import Experiment
import torch.nn as nn

# 1. Define a new experiment 
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Create your model class 
class RNN(nn.Module):
    #... Define your Class 

# 3. Train and test your model while logging everything to Comet
with experiment.train():
    # ...Train your model and log metrics 
    experiment.log_metric("accuracy", correct / total, step = step)

# 4. View real-time metrics in Comet
from pytorch_lightning.loggers import CometLogger

# 1. Create your Model

# 2. Initialize CometLogger
comet_logger = CometLogger()

# 3. Train your model 
trainer = pl.Trainer(
    logger=[comet_logger],
    # ...configs
)

trainer.fit(model)

# 4. View real-time metrics in Comet
from comet_ml import Experiment
from transformers import Trainer

# 1. Define a new experiment 
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Train your model 
trainer = Trainer(
    model = model,
    # ...configs
)

trainer.train()

# 3. View real-time metrics in Comet
from comet_ml import Experiment
from tensorflow import keras

# 1. Define a new experiment 
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Define your model
model = tf.keras.Model(
    # ...configs
)

# 3. Train your model
model.fit(
    x_train, y_train,
    validation_data=(x_test, y_test),
)

# 4. Track real-time metrics in Comet
from comet_ml import Experiment
import tensorflow as tf

# 1. Define a new experiment 
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Define and train your model
model.fit(...)

# 3. Log additional model metrics and params
experiment.log_parameters({'custom_params': True})
experiment.log_metric('custom_metric', 0.95)

# 4. Track real-time metrics in Comet
from comet_ml import Experiment
import tree from sklearn

# 1. Define a new experiment 
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Build your model and fit
clf = tree.DecisionTreeClassifier(
    # ...configs
)

clf.fit(X_train_scaled, y_train)
params = {...}
metrics = {...}

# 3. Log additional metrics and params
experiment.log_parameters(params)
experiment.log_metrics(metrics)

# 4. Track model performance in Comet
from comet_ml import Experiment
import xgboost as xgb

# 1. Define a new experiment
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Define your model and fit
xg_reg = xgb.XGBRegressor(
    # ...configs
)
xg_reg.fit(
    X_train,
    y_train,
    eval_set=[(X_train, y_train), (X_test, y_test)],
    eval_metric="rmse",
)

# 3. Track model performance in Comet
# Utilize Comet in any environment
from comet_ml import Experiment

# 1. Define a new experiment
experiment = Experiment(project_name="YOUR PROJECT")

# 2. Model training here

# 3. Log metrics or params over time
experiment.log_metrics(metrics)

#4. Track real-time metrics in Comet

Always Secure, Easily Trusted

Opik is backed by the Comet platform and built to the standards of the world’s largest organizations. With SOC 2, ISO 27001 and HIPAA compliance, your traces, prompts and evaluation data stay protected, whether you run in our cloud or deploy in your own environment.

HIPAA (Health Insurance Portability and Accountability Act) logo

HIPAA

ISO certified company stamp

ISO

AICPA SOC (System and Organization Controls) badge

SOC

Customer Testimonials

Built for Enterprise, Driven by Community

Comet’s end-to-end evaluation platform is trusted by innovative AI builders, data scientists, and platform engineers in the most demanding enterprise environments.

Google AI

“None of the other products have the simplicity, ease of use and feature set that Comet has.”

Ronny Huang
Research Scientist

AssemblyAI

“After discovering Comet, our deep learning team’s productivity went up. Comet is easy to set up and allows us to move research faster.”

Guru Rao
Head of AI

Read more
Pattern

“It’s very satisfying to feel more organized with my AI workflows, just being able to see everything in Opik. It makes me feel like I actually know what’s going on, instead of just hoping it worked in the background.”

Cayden Blake
AI Engineer

Read more
Ancestry

“We can seamlessly compare and share experiments, debug and stop underperforming models. Comet has improved our efficiency.”

Carol Anderson
Staff Data Scientist

Read more
Zencoder

“If you’re not iterating quickly, you’re falling behind. Being able to check that everything’s aligned and troubleshoot unexpected behaviors is crucial. Opik helps us move faster without losing quality. ”

DMITRII KRASNOV
ENGINEERING MANAGER

Read more
Uber

“Comet offers the most complete experiment tracking solution on the market. It’s brought significant value to our business.”

OLCAY CIRIT
STAFF RESEARCH & TECH LEAD

Read more
developer docs

FAQs

Learn more about Comet and the software products we offer for teams building with AI.

What is Comet and how does it relate to Opik?

Comet is our company name and we build and maintain three distinct but related software products: Opik for LLM observability and evaluation, Cost Intelligence for coding agent spend management, and Experiment Management for building, training, and fine-tuning ML models. 

What is Opik?

Opik is Comet’s open-source LLM observability and evaluation platform, for teams building agents and LLM applications that need to work reliably in production. Learn more about Opik→

What is Comet Experiment Management?

Experiment Management is Comet’s platform for ML practitioners, data scientists, and platform teams who are building, training, fine tuning, and monitoring models. It includes tools for experiment tracking, dataset versioning, hyperparameter tuning, model versioning, production monitoring, custom dashboarding and data visualization, and more. Customers like Uber use it to train computer vision models for autonomous vehicles, and ecommerce and entertainment customers use it to build personalization algorithms. Some customers using Opik to improve their agents also use Experiment Management to fine-tune their own SLMs and decision models for use in LLM-as-a-judge evaluation workflows. 

What is Comet Cost Intelligence?

Cost Intelligence is Comet’s coding agent spend management platform, for engineering teams using Claude Code, Codex, or Copilot. Cost Intelligence uses a deep integration to analyze each developer’s coding agent configuration and session behavior to optimize MCPs, skills, tools, default models, and more, so you can monitor and optimize coding agent token spend without hurting productivity. Learn more about Cost Intelligence→ 

Doesn’t Opik also track AI costs?

Yes. Opik tracks token cost and latency in an agentic system you’ve built, whereas Cost Intelligence tracks and optimizes token cost in a coding agent product you use. 

Can I use Opik for free, or do I need a paid plan?

Opik offers both a fully open-source, self-hosted option and a free managed cloud service. Developers can install Opik from GitHub and deploy it using Docker Compose or Kubernetes under the permissive Apache-2.0 license. For those who prefer a hosted solution, Opik Cloud provides free access to the platform’s complete set of LLM observability and evaluation capabilities, without restricting features to paid tiers. Both deployment options use the same underlying codebase, giving teams the flexibility to start for free and choose the hosting approach that best fits their needs.

How does Opik pricing work? 

Paid plans add operational headroom rather than unlocking capabilities: Pro Cloud adds customizable span limits and retention periods, and Enterprise adds flexible deployments, single sign-on, service accounts, support and uptime SLAs, and SOC 2, ISO 27001, ISO 9001, HIPAA, and GDPR compliance. The Pro plan is $19 per month flat, including up to 50 team members, 100k spans per month, and 60-day data retention, with additional spans and longer data retention periods available on a pay-as-you-go basis.

How easy is it to set up Opik and start tracing AI agents?

Getting started with Opik takes just a few minutes. Developers can either self-host the open-source platform or sign up for Opik Cloud, which offers a free, fully managed environment with minimal setup. The next step is enabling tracing in your application to capture agent activity and unlock Opik’s observability and evaluation features. This can be accomplished using coding agent skills, the Opik MCP server, or one of 60+ native integrations with popular LLM frameworks and development tools. Follow the Opik Quickstart Guide for step-by-step instructions.

Get started today, free.

You don’t need a credit card to sign up, and your Comet account comes with a generous free tier you can actually use—for as long as you like.

Try Opik Free
Get Demo

Products

  • Opik AI Observability
  • ML Experiment Management
  • ML Artifacts
  • ML Model Registry
  • ML Model Production Monitoring

Learn

  • Documentation
  • Opik University
  • Comet Blog
  • Deep Learning Weekly

Company

  • About Us
  • News
  • Events
  • Partners
  • Careers
  • Security & Compliance
  • Contact Us

Pricing

  • Pricing
  • Create a Free Account
  • Contact Sales
  • LinkedIn
  • X
  • YouTube
  • Facebook
G2 logo
Capterra badge showing a score of 4.4
Comet logo

©2026 Comet ML, Inc. – All Rights Reserved

Terms of Service

Privacy Policy

CCPA Privacy Notice

Cookie Settings

We use cookies to collect statistical usage information about our website and its visitors and ensure we give you the best experience on our website. Please refer to our Privacy Policy to learn more.