Written by: Mark Hull, Co-Founder and CEO, Exceeds AI
Key Takeaways
- Line-level AI provenance records which AI tool, model, session, and interaction mode produced each line of code. This detail lets engineering leaders answer board questions on AI ROI and trace production incidents.
- Cursor’s commit trailers and Agent Trace apply only to Cursor sessions, can be stripped by Git hooks, and do not provide portable, machine-readable attestation in multi-tool environments.
- Teams using several AI tools develop systematic attribution gaps. Those gaps understate AI contribution in board reports and block correlation between token spend and shipped output.
- Exceeds Ink closes these gaps by writing line-level, interaction-mode-classified attestations as Git Notes at commit finalization. These notes survive rebases and remain readable by any Git client.
- Engineering leaders who need audit-grade, multi-tool provenance and long-term AI technical debt tracking can start a free Exceeds AI pilot and see their attribution gaps within hours.
How Cursor Handles AI Code Attribution Today
Data from 4.2 million developers collected through February 2026 shows that AI-authored code now comprises 26.9% of all production code, up from 22% the prior quarter. Most developers now use an AI coding assistant. Cursor is the first choice for many of them, and its built-in attribution features are the default starting point for most teams.
Cursor’s attribution stack has four components. Commit trailers append structured key-value pairs such as Co-Authored-By and Cursor-Session-Id to commit messages at commit time. Agent Trace records the sequence of agent actions during a session and surfaces which files were touched and in what order. The Blame extension maps Cursor-attributed lines within standard git blame output so developers can see AI-touched lines alongside human-authored ones. Conversation Linking associates a commit with the Cursor conversation that produced it and enables session replay inside the Cursor IDE.
These features reflect real engineering work and help teams that live entirely inside Cursor. For a team using only Cursor, they provide a workable starting point for understanding AI contribution. The limitations appear once teams operate at scale, across multiple tools, or under audit conditions that demand portable, machine-readable proof. The first structural limitation is simple to state: Cursor’s attribution can be disabled or removed entirely.
How Developers Disable or Strip Cursor Attribution
Cursor’s attribution is not tamper-resistant. The settings panel exposes toggles that disable trailer injection completely. Developers working in shell environments have documented Git hook scripts on Reddit’s r/cursor community that strip trailers from commit messages before they reach the remote. A prepare-commit-msg hook running sed against the message file removes Cursor’s trailers in milliseconds and leaves no trace in remote history.
Privacy concerns drive much of this behavior. Developers on proprietary codebases or under contractor agreements sometimes strip attribution to avoid disclosing AI usage to clients. Others disable it to keep session IDs out of public repositories. The outcome is identical in every case. The attribution record disappears, and no downstream system can reconstruct it.
This override-prone design is a structural limitation rather than a configuration mistake. Any attribution method that lives in the commit message can be edited, rebased away, or stripped by a hook. Audit-grade provenance needs a storage layer that sits outside the commit message and writes at a point in the workflow where developer intervention is not routine.
Cursor Attribution vs Multi-Tool AI Provenance
Cursor’s attribution covers only Cursor sessions. It records nothing for code written in Claude Code, GitHub Copilot, Codex, or Windsurf. Faros AI’s 2026 Acceleration Whiplash report, drawing on two years of telemetry from 22,000 developers across more than 4,000 teams, shows that many teams have substantial AI tool adoption, and those teams do not standardize on a single tool. Engineers switch between Cursor for feature work, Claude Code for large refactors, Codex for batch transforms, and Copilot for inline autocomplete within a single sprint.
Single-tool attribution creates systematic gaps in provenance. A VP of Engineering reviewing AI ROI sees Cursor’s contribution but not Claude Code’s. A board report built on Cursor trailers alone understates AI authorship by the share contributed by other tools. An incident traced to an AI-authored module cannot be tied to a specific tool, session, or interaction mode when that module came from a tool Cursor’s trailers never tracked.
The same Faros AI report documented an 861% increase in code churn and a 242.7% rise in the incidents-to-PR ratio as organizations moved from low to high AI adoption. Those numbers only help governance when the provenance layer can attribute churn and incidents to specific tools and interaction modes. Cursor trailers cannot do that for non-Cursor sessions.
Exceeds Ink addresses this with per-tool checkpoint materializers. These dedicated capture modules for Claude Code, Cursor, and Codex resolve edit evidence against the actual working tree at commit finalization. The attestation is written as a Git Note at refs/notes/exceeds-ink, which is separate from the commit message, readable by any Git client, and portable across forks and mirrors. Every line carries its tool, model, session, turn, interaction mode, and timestamp. Lines that cannot be confidently attributed are recorded as unknown_lines rather than silently assigned to human or AI. The format is machine-readable JSON, not a human-readable trailer that a sed script can strip.
On fidelity, Cursor trailers record session-level metadata. Exceeds Ink records line-level attribution with interaction-mode classification that distinguishes plan, ask, agent, edit, and headless modes. On portability, Cursor trailers live in the commit message and disappear when the message is amended or rebased. Exceeds Ink’s Git Notes survive rebases and travel with the repository. On longitudinal tracking, Cursor provides no way to correlate a session’s output with production incidents 30 or 60 days later. Exceeds Ink’s per-commit attestation anchors that correlation. On audit readiness, Cursor trailers require Cursor to interpret them. Exceeds Ink’s JSON schema is readable by any Git client and by policy engines such as OPA.
Tracking AI Technical Debt Over Time
Larridin’s 2026 benchmarks indicate that elite teams maintain code turnover ratios below 1.3x vs human baselines, while healthy teams keep the AI vs human turnover ratio below 1.5x. These benchmarks only help when the provenance layer can distinguish AI-authored lines from human-authored lines at the commit level and then track what happens to those lines over the next 30 days.
GitClear data cited in Larridin’s 2026 benchmarks shows code churn rising from a 3.3% pre-AI baseline to 7.1% across 211 million changed lines analyzed. That trajectory signals technical debt. Churn data without provenance data cannot tell a manager whether the churn clusters in AI-authored lines, in a specific tool’s output, or in a particular interaction mode such as agent-without-plan.
Faros AI’s 2026 report also found that monthly incidents increased 57.9% under high AI adoption, which reinforces the incidents-to-PR pattern noted earlier. Outcomes for incidents after AI adoption vary widely by organization. The difference does not come from tool selection alone. It comes from whether the organization has provenance infrastructure that can identify which patterns produce incidents and correct them before they compound.
Exceeds AI’s longitudinal outcome tracking monitors AI-touched code over 30 or more days for incident rates, rework patterns, and maintainability signals. Ink’s per-commit attestation anchors this analysis. When an AI-authored module generates incidents at a higher rate than human-authored modules in the same subsystem, the platform surfaces that pattern and connects it to the tool, model, and interaction mode that produced the code. Managers receive a coachable signal instead of an unexplained metric.
Governance and Board-Ready AI Audit Trails
Boards, legal counsel, and auditors now ask questions that commit trailers cannot answer. They want to know what percentage of the codebase AI produced, backed by machine-readable records rather than estimates. They ask whether the organization can trace an AI-assisted incident back to the exact session, prompt, developer, and tool. They also ask whether a patent examiner can see precisely what role AI played in a given file.
Token-cost correlation is a related governance requirement because AI tool costs have escalated beyond simple seat licenses. Agentic AI coding tools introduce usage-based token costs of $200 to $2,000 or more per engineer per month on top of $20 to $60 seat licenses, costs that can exceed $600 per engineer per month at the high end. At this spend level, a CFO asking whether that investment is generating proportionate output cannot rely on Cursor trailers. The answer requires correlating token spend with shipped output such as lines attributed, commits produced, and session-to-merge velocity across every tool the team uses.
Exceeds Ink captures the underlying model behind each session and reads Cursor billing from Cursor’s own state database for exact accuracy. The platform then correlates that spend with attributed output and produces an Agentic ROI signal that finance and engineering can use together. Policy enforcement also becomes expressible because the attestation is structured JSON in the repository. Teams can block deploys when AI authorship exceeds a threshold in sensitive paths or require extra review on commits where agent mode produced more than a specified percentage of the diff.
The refs/notes/exceeds-ink format is the only attribution format that is simultaneously line-level, portable across Git hosts, auditable by any Git client, and written at commit finalization rather than reconstructed later. Cursor’s trailers do not provide that combination of properties.
How Exceeds Ink Delivers Authoritative Provenance
Exceeds Ink ships as a single Rust binary of roughly 10 MB with no Node or npm runtime dependency. It captures everything locally first. Every event lands in a SQLite database on the developer’s machine before any optional remote delivery. It never sits in the request path between engineers and their AI vendors and makes no calls to Anthropic, OpenAI, Microsoft, or any AI provider.
Ink uses a hook-direct model combined with per-tool checkpoint materializers. It does not run a long-lived daemon and does not install a PATH-shimmed Git binary. Dedicated capture modules for Claude Code, Cursor, and Codex resolve edit evidence against the actual working tree at commit finalization. Multi-edit Cursor sessions correctly retain human-typed lines, and Claude Code rewrites are attributed to Claude. Capture runs from standard Git hooks such as prepare-commit-msg, post-commit, and post-rewrite on a per-repo opt-in basis with no global Git config mutation.
Ink does not modify commit messages. The Git Note at refs/notes/exceeds-ink serves as the single source of provenance. Interaction-mode classification records whether the engineer was in plan, ask, agent, edit, or headless mode. No competitor publishes this signal, and it forms the basis for actionable coaching. The ink-prompting-coach skill installs directly into the developer’s own Claude Code or Cursor agent so coaching appears where the work happens instead of in a separate dashboard.
Privacy is configurable along four rungs: local only, aggregate only, abstracted replay, and full identified replay. Different teams in the same organization can choose different rungs. Git Notes store session hash references rather than inline transcripts, which reduces the PII attached to Git history.
Frequently Asked Questions
What is line-level AI provenance and why does it matter for audits?
Line-level AI provenance is a machine-readable record that identifies, for each line of code in a commit, which AI tool wrote it, which model was used, which session and turn produced it, what interaction mode was active, and what the token cost was. It is stored in a format that survives outside the originating tool. In Exceeds Ink’s case, this record appears as a Git Note at refs/notes/exceeds-ink that any Git client can read. For audits, this matters because auditors, legal counsel, and regulators need evidence, not estimates. A commit trailer that says “Cursor-Session-Id: abc123” tells an auditor that Cursor was open during the session. A line-level Git Note with a structured JSON schema tells an auditor exactly which lines were AI-generated, by which tool, in which mode, and at what cost. That record cannot be amended without leaving a trace in Git history.
How does Exceeds Ink differ from Cursor’s native trailers and Agent Trace?
Cursor’s trailers live in the commit message and can be stripped by a Git hook, amended away, or lost during a rebase. Agent Trace records the sequence of agent actions within a Cursor session but does not produce a portable, line-level attestation that travels with the repository. Exceeds Ink writes its attestation as a Git Note, which is separate from the commit message, at commit finalization before the commit is reachable for push. The attestation is line-level rather than session-level, covers all AI tools the team uses rather than only Cursor, classifies interaction mode per session, and is stored as machine-readable JSON readable by any Git client. Ink also captures token cost per session and correlates that spend with shipped output, which Cursor’s native features do not provide.
Can Exceeds Ink run alongside existing developer analytics platforms?
Yes. Exceeds Ink is designed to complement existing tools. Platforms like LinearB, Jellyfish, and Swarmia track metadata such as PR cycle times, commit volumes, and review latency but cannot distinguish AI-authored lines from human-authored lines. Exceeds Ink provides the code-level provenance layer those platforms lack. Because Ink’s Git Notes attestation is portable and machine-readable, its data can also flow directly into a data warehouse or BI tool, which makes it a natural input to existing analytics stacks. Exceeds AI integrates with GitHub, GitLab, Azure DevOps, JIRA, and Linear so the provenance data appears within workflows teams already use.
What is the setup time and security posture for Exceeds Ink?
Setup takes hours, not weeks. GitHub or GitLab OAuth authorization takes about five minutes. Per-repo opt-in and adapter wiring for Claude Code, Cursor, and Codex can be completed the same day. First insights are available within 60 minutes. Complete historical analysis arrives within four hours, and real-time updates appear within five minutes of new commits. On security, Ink uses HMAC-SHA256-signed remote ingest with revocable per-machine tokens, LLM-based prompt redaction before any prompt content is persisted, and an aggregate-only mode controlled by a single environment variable that keeps transcripts off the wire entirely. Ink does not run a long-lived daemon, does not install a PATH-shimmed Git binary, and does not mutate global Git config. Local servers bind to loopback only. A self-host option is available with a configurable remote ingest URL. Exceeds AI is working toward SOC 2 Type II compliance and has passed enterprise security reviews, including a formal two-month evaluation at a Fortune 500 retailer.
When are Cursor’s native attribution tools sufficient?
Cursor’s trailers and Agent Trace are sufficient for small teams that use only Cursor, operate in environments where audit-grade provenance is not required, and focus on session-level visibility for individual developers rather than organizational governance. A team of fewer than 20 engineers that uses Cursor exclusively, does not need to correlate AI authorship with production incidents over time, and is not subject to board-level ROI reporting or compliance requirements can rely on Cursor’s native features as a starting point. The limitations become material when teams use multiple AI tools, when managers need to track AI technical debt over 30 or more days, when token spend must be correlated with shipped output, or when auditors require portable machine-readable attestation that survives outside the Cursor ecosystem.
Conclusion: Turn Cursor Attribution into Enterprise-Grade Proof
Cursor’s commit trailers and Agent Trace are useful within their scope. They provide session-level visibility for Cursor users and a starting point for teams that are just beginning to think about AI attribution. They do not meet the needs of engineering leaders who must answer the board on AI ROI, govern token spend across a multi-tool team, trace production incidents to their AI-authored origin, or produce audit-grade provenance that survives outside the Cursor ecosystem.
With AI code now representing more than a quarter of production codebases and incidents-to-PR ratios rising 242.7% under high AI adoption, the cost of inadequate provenance is measurable and growing. Healthy AI ROI averages 2.5 to 3.5x and reaches 4 to 6x for top-quartile teams. Those returns only materialize when cost calculations include actual token and usage-based expenses and when attribution systems can connect AI-generated changes to verifiable delivery and quality outcomes.
Exceeds Ink delivers line-level, portable Git Notes attestation across Cursor, Claude Code, Codex, GitHub Copilot, and Windsurf. It writes that attestation at commit finalization, before the commit is reachable for push, in a machine-readable format that any Git client can resolve. The Exceeds AI platform turns that provenance into board-ready ROI reports, longitudinal technical debt tracking, and manager coaching surfaces that spread effective patterns across the organization.
Cursor built a useful foundation. Exceeds Ink turns that foundation into enterprise-grade proof.
See your team’s AI provenance gaps and start your pilot today.