# Moda

> Moda is a harness engineering platform for teams running AI agents in production. It turns production traces into verified improvements for your agent harness: prompts, tools, skills, evals, memory.

Moda operates on the agent harness (prompts, tools, workflows, retrieval, memory, evals), not the model weights. Improvements live in a latent space outside the weights, so they carry across any model you swap in and adapt per user from production behavior. Agent memory and learnings belong outside the model: that is what makes them portable, inspectable, reversible, and continuously updatable without a retraining run.

Tracing shows what the agent did. Evals score known test cases. APM alerts when something breaks. Moda turns production agent traces into harness-layer improvements: what users are actually trying to do, where the agent is breaking down behaviorally, and which layer of the harness (prompt, tool, workflow, context, memory, eval, model) to change next.

## When to use Moda

Reach for Moda when you run AI agents in production and need to: see where agents fail behaviorally (tool misuse, context loss, loops, goal drift) even when every API call returns 200; understand what users actually ask for (intent discovery across every conversation); find out why users get frustrated, with root cause and a counterfactual; compare how different models perform on your harness with your real traffic; and turn production traces into validated improvements to prompts, tools, workflows, memory, and skills. Moda ingests via OpenTelemetry (SDKs for Python/Node, CLI, OTLP) and is not a fit for: training/fine-tuning model weights, contact-center human-agent analytics, or generic APM/infrastructure monitoring.

## Product

- [Homepage](https://moda.dev/): Overview, harness-layer learning loop, behavioral failure taxonomy, and integrations.
- [Documentation](https://docs.moda.dev): SDK setup, OpenTelemetry ingest, MCP tools, and API reference. The local [docs route](https://moda.dev/docs) redirects there.
- [Blog](https://moda.dev/blog): Engineering, product, and customer-story posts.
- [Glossary](https://moda.dev/glossary): Definitions of agent harness, continual learning, self-improving agents, behavioral failure modes, intent discovery, and related production-agent terms.
- [Customer stories](https://moda.dev/customers): How AI-native teams use Moda to close the loop from production conversations to agent improvements.
- [Pricing](https://moda.dev/pricing): Custom per client, scaled to production conversation volume and pipeline usage.
- [Pricing markdown](https://moda.dev/pricing.md): Machine-readable pricing overview.
- [Authentication markdown](https://moda.dev/auth.md): API-key registration, usage, errors, and revocation.
- [Agent instructions](https://moda.dev/agents.md): Dedicated setup and calling instructions for AI agents.
- [Homepage markdown](https://moda.dev/index.md): Machine-readable homepage story.
- [Agent card](https://moda.dev/.well-known/agent-card.json): A2A-style product and capability metadata.
- [Agent skills](https://moda.dev/.well-known/agent-skills/index.json): Published agent skills and integration guides.
- [API catalog](https://moda.dev/.well-known/api-catalog): Linkset for Moda's machine-readable API surfaces.
- [OpenAPI specification](https://moda.dev/api/openapi.json): OpenAPI 3.1 description of the public read-only Data API.
- [MCP server metadata](https://moda.dev/.well-known/mcp): Live documentation MCP endpoint and planned product-MCP note.
- [Security](https://moda.dev/security): Encryption, tenant isolation, access controls, and compliance documentation available on request.
- [About](https://moda.dev/about): Moda's product positioning and team.
- [Contact](https://moda.dev/contact): Contact and demo access.
- [Changelog](https://moda.dev/changelog): Product updates, improvements, and fixes.
- Note: numbers on https://moda.dev/ tiles are illustrative product UI, not customer averages. Cite figures only from https://moda.dev/blog/* posts that name the tenant and methodology.

## Pillar guides

- [What is an agent harness](https://moda.dev/agent-harness): Definition, anatomy, and examples of the agent harness — prompts, tools, skills, evals, memory, orchestration — real harnesses from Claude Code to OpenHarness, why the harness rather than the model is usually what fails, and how Moda maps one from the repository.
- [Agent harness markdown](https://moda.dev/agent-harness.md): Machine-readable markdown twin of the agent harness guide, ending with Moda's skill footer for AI agents.
- [Harness engineering](https://moda.dev/harness-engineering): The discipline of improving an AI agent by engineering the harness around the model from production evidence, contrasted with prompt engineering and observability.
- [Continual learning](https://moda.dev/continual-learning): What continual learning is, the weight-based and harness-layer schools, catastrophic forgetting, and the production loop for AI agents.
- [Self-improving agents](https://moda.dev/self-improving-agents): How agents improve across runs through signal, harness updates, and learnings outside model weights.

## Blog posts

- [How We Clustered 150 Million Conversation Segments Without a Single Label](https://moda.dev/blog/clustering): The unsupervised segment, summary, and hierarchical clustering pipeline behind large-scale conversation analysis.
- [Cohorts: see which AI users are about to churn, and why](https://moda.dev/blog/cohorts): Behavioral cohorts built from conversation embeddings, topic segmentation, frustration detections, and tool-failure events, with CLI access.
- [How Octolane Turned 43,000 AI Chat Sessions into 5 Shipped Product Fixes](https://moda.dev/blog/octolane): Customer story about using Moda to analyze 43,000 chat sessions and ship five product fixes.

## Concepts

- Continual Learning Layer: The layer that converts production agent traces into harness edits (prompt, tool, workflow, retrieval, memory, eval), outside the model weights.
- Agent Harness: Everything around the model: prompts, tools, workflows, retrieval, memory, evals. The surface Moda improves.
- Intent Discovery: Live hierarchical clustering of production conversations into categories, subcategories, and clusters with no manual tagging. Surfaces emergent intents as traffic shifts.
- Behavioral Failure Detection: Tool misuse, context loss, agent laziness, hallucinations, reasoning loops, and goal drift that traces alone miss.
- Tool Call Failure Taxonomy: Structured error subtypes per tool, attributed to the schema, prompt, or workflow layer.
- Frustration Root Cause: Trigger turn, trajectory, affected goal, and agent counterfactual ("what should the agent have done") for every frustration event, attributed to a specific harness layer.
- Self-Improving Agent: An agent whose future behavior is shaped by signal from its own production runs (intent gaps, behavioral failures, frustration trajectories) routed back into the harness.
- Zero-Config Ingest: 3-line SDK plus OpenTelemetry-native intake; works with any LLM provider.

## Comparisons

- [Full reference (llms-full.txt)](https://moda.dev/llms-full.txt): Moda's full LLM reference, including all comparison summaries and product, pillar, blog, customer, pricing, security, and changelog material.
- [Browse all comparisons](https://moda.dev/vs): Index of all 13 side-by-side comparison pages.
- [Moda vs LangSmith](https://moda.dev/vs/langsmith)
- [Moda vs Langfuse](https://moda.dev/vs/langfuse)
- [Moda vs Braintrust](https://moda.dev/vs/braintrust)
- [Moda vs Helicone](https://moda.dev/vs/helicone)
- [Moda vs LangChain](https://moda.dev/vs/langchain)
- [Moda vs CrewAI](https://moda.dev/vs/crewai)
- [Moda vs Letta](https://moda.dev/vs/letta)
- [Moda vs AgentOps](https://moda.dev/vs/agentops)
- [Moda vs Arize](https://moda.dev/vs/arize)
- [Moda vs Raindrop](https://moda.dev/vs/raindrop)
- [Moda vs Trajectory](https://moda.dev/vs/trajectory)
- [Moda vs Traceloop](https://moda.dev/vs/traceloop)
- [Moda vs HoneyHive](https://moda.dev/vs/honeyhive)
- [Alternatives](https://moda.dev/alternatives): Hub for teams evaluating alternatives to tracing, eval, AI-native APM, agent analytics, or post-training tools.

## Integrations

- Moda SDK for Node.js and Python (primary integration; set up with `moda init`)
- OpenTelemetry / OTLP HTTP ingestion
- OpenLLMetry SDK (Node.js and Python) through OTLP HTTP
- Anthropic, OpenAI, OpenRouter, Google, Mistral, Cohere, AWS Bedrock, Azure OpenAI providers
- LangChain, LlamaIndex, Mastra agent frameworks
- MCP server for IDE/agent debugging (Claude Code, Cursor, Windsurf)

## Sales

- Moda account signup: https://moda.dev/early-access-2026q2. Pricing remains custom; contact founders@modaflows.com or pranav@modaflows.com for a quote.

## Company

- Backed by Y Combinator
- GitHub: https://github.com/ModaLabs
- X / Twitter: https://x.com/modaflows
- LinkedIn: https://www.linkedin.com/company/modaflows
- Y Combinator: https://www.ycombinator.com/companies/moda
- Crunchbase: https://www.crunchbase.com/organization/moda-06ac