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

Trusted by the most innovative AI teams
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
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
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
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
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





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.

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.

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.

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.

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.
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.

“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
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
60+
Integrations
182
Available via MCP & Coding Agent Skills
8.6k
PRs Closed Since 2023
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.
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!"}
]
)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 Cometfrom 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 Cometfrom 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 Cometfrom 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 Cometfrom 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 Cometfrom 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 Cometfrom 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 CometAlways 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

ISO

SOC
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.
“None of the other products have the simplicity, ease of use and feature set that Comet has.”
Ronny Huang
Research Scientist
“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

“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
“We can seamlessly compare and share experiments, debug and stop underperforming models. Comet has improved our efficiency.”
Carol Anderson
Staff Data Scientist

“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
“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
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.