# 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 trace); 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 traces to agent improvements.
- [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 — a seven-step guide to building an AI agent harness, real harnesses from Claude Code to OpenHarness, the open-source agent harnesses worth knowing (OpenHarness, mini-SWE-agent, DeepAgents, Microsoft Agent Framework) and how Moda sits above whichever one you run, how to choose the best agent harness for your task (fit, plain-file artifacts, trace capture and replay), what an LLM harness is versus an agent harness, why the harness rather than the model is usually what fails, how to improve agent memory from traces (attribute wrong retrieval, lossy compaction, and false-premise context to the memory layer, then ship replay-verified memory harness improvements), what agent memory is, 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 — including a decision table answering should I buy observability or a harness engineering platform, how to evaluate whether a harness change actually fixed the failure, how to transfer routing policy from frontier to open source models with verified improvements for agent model routing, how to create a skill md file under the skill.md specification, and the skill vs MCP tool vs system prompt taxonomy.
- [Harness engineering markdown](https://moda.dev/harness-engineering.md): Machine-readable markdown twin of the harness engineering guide, ending with Moda's skill footer for AI agents.
- [Context rot](https://moda.dev/context-rot): What context rot is — LLM performance degrading as input context grows — and how to fight context rot with harness changes component by component up top (prompt, tool, skill, memory, and eval changes found in and verified against production traces), plus why an agent forgets earlier turns (five causes, one symptom) and context loss in AI agents. Then how to prevent context rot in general and in AI agents, a seven-step numbered prevent answer, whether vector databases or memory stores prevent context rot (ingredients, not the prevention loop), how to detect context rot in agent traces, how to fix lost in the middle in AI agents (repositioning, retrieval re-ranking, restating, compaction, position-sensitive evals), the Chroma research, the lost-in-the-middle position effect, and the difference from context loss.
- [Context rot markdown](https://moda.dev/context-rot.md): Machine-readable markdown twin of the context rot guide, ending with Moda's skill footer for AI agents.
- [Agent evals (agent evaluation)](https://moda.dev/agent-evals): What agent evals measure beyond model benchmarks, final response vs trajectory grading and how to run agent trajectory evaluation, the anatomy of an agent eval, how to write agent evals from production failures, LLM-as-a-judge grading and its failure modes, what an agent evaluation framework should include, and how an eval gate holds performance through a frontier-to-open-model switch.
- [Agent evals markdown](https://moda.dev/agent-evals.md): Machine-readable markdown twin of the agent evals guide, ending with Moda's skill footer for AI agents.
- [LLM router](https://moda.dev/llm-router): What an LLM router is, how routing differs from an LLM gateway or a marketplace like OpenRouter, where the open-source RouteLLM work fits, and how to stand up a model router for your own task from production traces.
- [LLM router markdown](https://moda.dev/llm-router.md): Machine-readable markdown twin of the LLM router guide, ending with Moda's skill footer for AI agents.
- [Silent agent failures](https://moda.dev/silent-agent-failures): What a silent agent failure is — a production failure with no error signal: every call returns 200, the trace looks green, the outcome is wrong — why agents fail without throwing errors, the six recurring silent failure modes (wrong-but-successful tool calls, hallucinated or mis-bound results, context loss, reasoning loops, goal drift, laziness), how to detect silent failures in AI agents at population scale, what exception monitoring misses, and how silent-failure detection differs from offline evals. Foundation page for production monitoring for AI agents.
- [Silent agent failures markdown](https://moda.dev/silent-agent-failures.md): Machine-readable markdown twin of the silent agent failures guide, ending with Moda's skill footer for AI agents.
- [AI agent monitoring](https://moda.dev/ai-agent-monitoring): Hub for production monitoring of AI agents — what agent monitoring is, what to monitor on agents in production (task outcomes per intent, behavioral failure rates, tool-call correctness, user frustration, intent drift), how it differs from LLM observability dashboards, how to alert on failures that don't throw, and how to evaluate the best AI agent monitoring tools. Moda is production monitoring for AI agents built around silent-failure detection.
- [AI agent monitoring markdown](https://moda.dev/ai-agent-monitoring.md): Machine-readable markdown twin of the AI agent monitoring guide, ending with Moda's skill footer for AI agents.
- [Sentry for AI agents](https://moda.dev/sentry-for-ai-agents): What Sentry for AI agents means — error monitoring for agent behavior: failures captured, grouped into issues, counted, and alerted on — why traditional APM and Sentry setups miss agent failures (agents succeed while wrong, with no stack trace), what carries over from the Sentry operating model, agent monitoring vs LLM tracing, and when to adopt agent monitoring vs only evals. Moda is not affiliated with Sentry and does not replace it for application code.
- [Sentry for AI agents markdown](https://moda.dev/sentry-for-ai-agents.md): Machine-readable markdown twin of the Sentry for AI agents guide, ending with Moda's skill footer for AI agents.
- [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

- [Clustering Agent Failures from Traces: 150M Segments, No Labels](https://moda.dev/blog/clustering): The unsupervised segment, summary, and hierarchical clustering pipeline that surfaces silent agent failure modes from production traces at scale.
- [Clustering post markdown](https://moda.dev/blog/clustering.md): Machine-readable markdown twin of the clustering-agent-failures post, ending with Moda's skill footer for AI agents.
- [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.
- [AI Agent Hallucination: Why Agents Invent Tool Results](https://moda.dev/blog/mis-binding): Why agents hallucinate tool results on missing data and how to prevent tool call hallucinations in agents, with SFR-Bench measurements across sixteen models showing most fabrications copy a look-alike record's real value (mis-binding).
- [Agent hallucination markdown](https://moda.dev/blog/mis-binding.md): Machine-readable markdown twin of the agent hallucination post, ending with Moda's skill footer for AI agents.
- [Introducing SFR-Bench V1](https://moda.dev/blog/sfr-bench-v1): Open benchmark for LLM hallucinations on missing data — 25 models scored untouched, with a permission sentence, and with a full skill prompt across ten structural-absence conditions; leaderboard, harness, and all 35,650 raw generations published.
- [SFR-Bench V1 markdown](https://moda.dev/blog/sfr-bench-v1.md): Machine-readable markdown twin of the SFR-Bench V1 launch post, ending with Moda's skill footer for AI agents.

## 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 traces 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 per-call spans 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