Agent Trace: The Open Standard for Code Context Graphs

What is Agent Trace?

On January 29, 2026, Cognition AI—the company behind the AI software engineer Devin—announced Agent Trace, an open specification for recording AI contributions alongside human authorship in version-controlled codebases. The specification was released as an RFC (Request for Comments) by Cursor, signaling broad industry alignment on the need for a standardized approach to AI code attribution.

At its core, Agent Trace answers a question that has become increasingly urgent as AI coding assistants reshape software development: who actually wrote this code, and what was the context behind it? In a world where AI-generated code is becoming the norm rather than the exception, the ability to trace authorship—and more importantly, the conversational reasoning that produced it—is no longer optional. It is essential infrastructure.

“If git tracked ‘Lines of Code’ as the primary measure in the pre-AI era, Agent Traces mark the new era where code is commodity and context is the precious resource.”

Agent Trace doesn't just record whether code was human-authored or AI-generated. It connects every code range to the conversation that produced it—the prompts, the reasoning, the iterations, and the decisions that led to the final implementation. This conversational context is what transforms raw code attribution into a genuine context graph for software development.

The Collaborators Behind the Standard

What makes Agent Trace remarkable is not just the specification itself, but the breadth of industry support it received from day one. Cognition AI joined forces with a coalition of leading AI and developer tooling companies to back the standard:

The specification is published on GitHub at cursor/agent-trace under the CC BY 4.0 license, ensuring it remains open, forkable, and accessible to the entire developer ecosystem. The choice of Creative Commons licensing rather than a more restrictive software license underscores the intent: this is a shared standard, not a proprietary advantage.

The collaboration between competing AI coding tools is itself a signal of how fundamental this problem is. When Cursor, Cognition, and Google Jules all agree that a shared attribution standard is needed, it reflects a collective recognition that the industry cannot afford fragmented approaches to code provenance in the AI era.

How Agent Trace Works

At the technical level, Agent Trace introduces a JSON-based “trace record” that connects code ranges to conversations and contributors. The design is intentionally minimal yet expressive, capturing the essential metadata without imposing heavy tooling requirements.

{
  "version": "0.1",
  "traces": [
    {
      "file": "src/components/Dashboard.tsx",
      "ranges": [
        { "start": 1, "end": 45 }
      ],
      "attribution": "ai",
      "model": "claude-3.5-sonnet",
      "conversation_ref": "conv_abc123",
      "timestamp": "2026-01-30T14:22:00Z"
    },
    {
      "file": "src/components/Dashboard.tsx",
      "ranges": [
        { "start": 46, "end": 78 }
      ],
      "attribution": "human",
      "contributor": "developer@example.com"
    },
    {
      "file": "src/utils/api.ts",
      "attribution": "mixed",
      "model": "gpt-4o",
      "conversation_ref": "conv_def456"
    }
  ]
}

Why Agent Trace Matters

The emergence of Agent Trace signals a fundamental shift in how we think about software development. For decades, git has tracked “who committed what” as the canonical record of authorship. But in a world where an increasing share of code is generated, reviewed, or substantially modified by AI systems, git's commit-level attribution model is no longer sufficient.

Consider the practical implications. A developer opens Cursor, describes a feature in natural language, receives a multi-file implementation from Claude, manually adjusts a few lines, and commits the result. Git records that developer as the sole author. But the real story is richer—and the real value lies in understanding that story: the conversation that guided the implementation, the model that generated it, and the specific human judgment applied to the output.

Agent Trace matters for several overlapping reasons:

• ●Code Review and Trust — Reviewers can see which parts of a pull request were AI-generated and which were hand-written, applying appropriate levels of scrutiny to each
• ●Debugging and Maintenance — When a bug surfaces in AI-generated code, engineers can trace back to the conversation that produced it, understanding the original intent and constraints
• ●Compliance and Licensing — Organizations can track their AI code footprint for licensing, intellectual property, and regulatory compliance purposes
• ●Team Analytics — Engineering leaders can understand AI adoption patterns, measure productivity gains, and identify where AI-assisted development is most effective
• ●Knowledge Preservation — The conversational context behind code decisions is preserved as institutional memory, rather than being lost when a chat session ends

Connection to Context Graphs

Agent Trace is, fundamentally, the code-specific implementation of the broader context graph concept. Foundation Capital's definition of a context graph as “a living record of decision traces stitched across entities and time so precedent becomes searchable” maps directly onto what Agent Trace provides for software development.

The connection runs deeper than surface-level analogy. In the same way that enterprise context graphs capture the “why” behind business decisions—the exceptions, overrides, and escalation paths that live in Slack threads and people's heads—Agent Trace captures the “why” behind code decisions: the prompt engineering, the model selection, the iterative refinement that shaped the final output.

“Over time, that context graph becomes the real source of truth for autonomy. Agent Trace is how that truth gets recorded in codebases.”

As AI coding agents become more autonomous—writing entire features, fixing bugs independently, and even reviewing each other's code—the context graph they build through Agent Trace records becomes the institutional memory of the codebase. New agents (or new human engineers) joining a project can query this context to understand not just what the code does, but why it was written this way, what alternatives were considered, and what constraints shaped the implementation.

Performance Impact

Beyond attribution and compliance, Agent Trace has direct implications for AI coding performance. The core insight is that Agent Traces that progressively expose context to coding agents lead to significant improvements in output quality, cost efficiency, and developer productivity.

The performance mechanism is straightforward. When an AI coding agent encounters a file or function that has associated trace records, it can retrieve the original conversation context—the requirements, the design rationale, the edge cases discussed—and use that context to inform its current task. Instead of generating code in a vacuum, the agent is building on the accumulated understanding of the codebase.

For engineering teams, this translates to measurable productivity improvements. Developers spend less time re-explaining context to AI assistants. Code review cycles shorten because reviewers can see the original intent alongside the implementation. And onboarding new team members becomes faster when the codebase carries its own decision history.

The Technical Specification

The Agent Trace specification defines a minimal but extensible schema for trace records. Understanding the key components helps teams plan their adoption strategy.

Getting Started

Agent Trace is designed for incremental adoption. Teams don't need to overhaul their existing workflows to begin capturing value. Here is a practical path to getting started:

1. 1

   Read the Specification

   Start by reviewing the RFC on GitHub at cursor/agent-trace. The specification is concise and well-documented. Understanding the schema before implementing helps teams make informed decisions about granularity and storage.

2. 2

   Start with File-Level Attribution

   Begin by tracking attribution at the file level. This is the simplest entry point and provides immediate value for code review and team analytics. As tooling matures, you can transition to line-level tracking for critical codepaths.

3. 3

   Choose a Storage Strategy

   Decide where trace records will live. Options include JSON sidecar files in the repository, git notes attached to commits, or an external database. Each approach has tradeoffs around discoverability, version control, and query performance.

4. 4

   Integrate with Existing Git Workflows

   Agent Trace is designed to complement, not replace, git. Trace records can be generated as part of commit hooks, CI/CD pipelines, or IDE integrations. Tools like Cursor and Devin are already building native Agent Trace support into their platforms.

5. 5

   Build Context Retrieval

   The highest-value integration is enabling AI agents to query trace records when working on code. When an agent opens a file with associated traces, it can automatically retrieve the conversation context that produced that code—making every subsequent interaction more informed and accurate.

Frequently Asked Questions