Know which AI wrote
every line.

Human, AI, or paste. Tagged on every line. Graded by confidence. From your editor to the whole org.

$npm install -g @omnitype-code/cli
tools
Claude Code
Cursor
Windsurf
Copilot
Codex
Cline
Gemini CLI
Amp
OpenCode
Droid
Firebender
Pi
Antigravity
Aider
Continue
Goose
Claude Code
Cursor
Windsurf
Copilot
Codex
Cline
Gemini CLI
Amp
OpenCode
Droid
Firebender
Pi
Antigravity
Aider
Continue
Goose
Claude Code
Cursor
Windsurf
Copilot
Codex
Cline
Gemini CLI
Amp
OpenCode
Droid
Firebender
Pi
Antigravity
Aider
Continue
Goose
languages
TypeScript
Python
Go
Rust
Java
C++
Ruby
Swift
Kotlin
PHP
C#
Dart
Hindi
Arabic
Korean
SQL
Scala
Elixir
Haskell
Zig
TypeScript
Python
Go
Rust
Java
C++
Ruby
Swift
Kotlin
PHP
C#
Dart
Hindi
Arabic
Korean
SQL
Scala
Elixir
Haskell
Zig
TypeScript
Python
Go
Rust
Java
C++
Ruby
Swift
Kotlin
PHP
C#
Dart
Hindi
Arabic
Korean
SQL
Scala
Elixir
Haskell
Zig
Features
Per-line attribution
See exactly who wrote what.
Human, AI, or paste. Tagged live as you type.
1
function processPayment(order) {
2
const validated = schema.validate(order);
3
if (!validated.ok) throw new Error();
4
return stripe.charge(order);
5
}
Human
AI
Paste
Model detection
Which model, which line.
Claude, GPT-4o, Gemini. Detected automatically.
claude-sonnet-4-6Claude Code
48%
gpt-4oCursor
31%
gemini-2.0-flashGemini CLI
21%
Git-native
Attribution per commit.
Stored as git notes. Survives rebase and squash once configured.
a4f2c1add payment flow71%29%
b8e3d0fix validation bug94%6%
c1a9f2refactor auth module33%67%
Team dashboard
Real visibility. No self-reporting.
AI use per dev, model, and week. Personal, repo, and org views.
rishav
38% AI
alex
72% AI
priya
19% AI
sam
56% AI
Prompt IQ
Find your best prompts.
Score every prompt by the code that ships. Spot the keywords and models that deliver.
score = shipped / generated
CLI
Works outside VS Code too.
JetBrains, Neovim, any terminal editor.
$omnitype blame src/app.ts
$omnitype status
$omnitype hooks install
Open protocol
Any tool can integrate.
Structured events from the SDK, or one JSON file. Works with Claude Code out of the box.
npm i @omnitype-code/agent-sdk
CLI · Works in any editor

Not a VS Code user?
We got you.

MIT LicensemacOS · Linux · Windows
omnitype — zsh
@omnitype-code/cli
Install
$npm install -g @omnitype-code/cli
Any editor
Cursor, JetBrains, Neovim, Zed
Git-native
Hooks + git notes on every commit
Open protocol
Signal any model from any tool
Commands
omnitype daemon
Track any IDE in real time
omnitype blame src/index.ts
Per-line AI attribution
omnitype hooks install
Add git hooks to current repo
omnitype signal --model gpt-4o --tool aider
Signal active model manually
omnitype setup-vscode-hook
Enable all VS Code forks at once
omnitype status
Show active model and confidence
Provenance Engine

AI% doesn't tell
you if code is good.
That's the point.

A 95% AI commit can be great engineering or a liability. Provenance gives you the data to ask the right question, not a verdict.

Reviewers read with context
See which lines are AI-suggested before opening the diff. Same decision, better frame.
Managers spot patterns early
A shift from 20% to 90% AI overnight is a signal. Provenance surfaces it automatically.
Teams understand their tools
Know which repos, files, and developers rely on AI most. Answer questions you could not ask before.
COMMIT · 95% AI
Great engineering
AI 95%
Human 5%
src/queue.ts
97%AI scaffold
src/worker.ts
88%AI scaffold
fix/race.ts
0%← the actual insight

A dev reads a 400-line AI suggestion, spots the race condition on line 312, writes 8 lines to fix it, ships. The commit is 95% AI. The 5% is what matters.

Same number. Different context. Provenance surfaces the data. Your team supplies the judgment.

For Engineering Teams

Know how your
codebase gets built.

Every line classified at write-time: typed manually, AI-generated, or pasted. No surveys, no self-reporting. Objective data, like logs and metrics.

Overview
Profiles
Alerts
Composition shift detected — AI-generated lines up 40% this week
A
alex.chenAI-Assisted
Senior Eng
108 wpm
J
jordan.kAI-Heavy
Backend
61 wpm
S
sarah.mManual-First
Fullstack
94 wpm
T
tom.wrightAI-Assisted
Frontend
76 wpm
Manual
AI
Paste
  • Observability, not surveillance
    Provenance is infrastructure data, like CPU or latency. It tells you what is happening, not whether to trust your developers.
  • Code review with full context
    Reviewers know which lines came from AI before they open the diff. They still decide, but with the right information.
  • Answer the questions that matter
    "Which repos use AI most?" "Did that refactor shift our composition?" "Where is AI helping?" Now you can answer these.
  • Bulk hiring assessments
    Send one link to 2,000 candidates. AI usage, paste rate, and manual code ratio ranked automatically. No spreadsheets.
0
Setup required. Install and it just runs.
AI tools supported, tool-agnostic by design
100%
Passive collection. Devs just code normally.
1
Link to run a 2,000-seat assessment
OmniType Attribution Protocolv2
Open Standard

Signed SDK events, or one JSON file. Every span graded by confidence tier. Claude Code ships it natively.

~/.omnitype/active-model.json
View protocol
Free for individuals, always

Start in minutes.

VS Code extension or CLI. Both free.

VS Code Extension
Cursor, Windsurf, any VS Code fork
Per-keystroke attribution
Paste detection
Live sidebar
Install from Marketplace
CLI
JetBrains, Neovim, Zed, any editor
Git hooks
Blame per-line
Daemon mode
$npm install -g @omnitype-code/cli
01
Install
Extension or CLI
02
Sign in
30 seconds
03
Code
Runs silently
04
See it
Live attribution
FAQ

Questions worth
answering honestly.

No fluff. How it works, what it sees, and what it doesn't.

It tells you — and your team — how your codebase actually gets built. Lines are tagged as manually typed, AI-generated, or pasted, and that attribution travels with your commits so you have an honest, ongoing record of how code authorship breaks down.

The VS Code extension watches how text enters your editor. Characters you type one by one are marked manual, a suggestion you accept from Copilot, Cursor, or Codeium is marked AI, and anything inserted with Ctrl+V is marked paste. Where the editor gives a clear signal — a keystroke, a paste, an accepted completion — attribution is exact. For bulk changes from external tools it uses the best available signal and labels the result with a confidence level, so a composition is an honest estimate, never a verdict.

Your source files stay on your machine — the extension analyzes them locally and only syncs the resulting composition ratios, something like '68% manual, 24% AI, 8% pasted' per commit. The one exception is prompt insights, an opt-in feature: when enabled, the prompts you send to AI tools are captured so the dashboard can show what works. If you paste code into a prompt, that text travels with the prompt. You can turn prompt capture off at any time.

When you install the extension, it sets up git hooks in your workspace. Every time you commit and push, those hooks attach provenance metadata to the commit. Your org dashboard then shows a per-file, per-branch, per-contributor breakdown — built entirely from commit history.

Your composition ratios and overall coding activity — the manual / AI / paste mix of your commits and how much you've been coding. They never see your source files or diffs. If your team turns on prompt insights, the prompts you send to AI tools are part of that view (so the team can learn what works), and you can switch prompt capture off whenever you want. It's there to understand how code gets built, not to watch you.

A picture of how your team's code gets written — the manual vs AI mix per repo and branch, adoption of AI tooling, and shifts in those patterns worth a conversation. It's designed to start questions, not hand you a verdict on anyone. You only see members assigned to your team, you see aggregates rather than individual diffs or code, and developers can see exactly what you see about them.

No noticeable impact. It works from editor events as you type and keeps a small local index so attribution survives restarts. There's no keylogging and no remote scanning — the analysis runs on your machine and only composition ratios leave it.

The extension tracks files as you open and edit them. Files you haven't touched since installing it, or files generated by tools like npm or build pipelines, won't appear — they were never typed. Coverage grows naturally as you work.

Because they usually are. package-lock.json is written by npm — you never typed it. tsconfig.json often gets auto-filled by IntelliSense. So the tag is doing its job, but these files just add noise: add generated files to .omnitype/ignore to exclude them from the dashboard entirely.

It's a deliberate practice tool — you practice typing real code in the languages you actually use, so your muscle memory matches your daily work. Think of it as a gym for your fingers. It's completely optional and separate from the provenance tracking.

The VS Code extension, provenance tracking, and individual dashboard are free. Team dashboards and org features require a plan. Assessment packs for hiring are available as one-time purchases.

Install the OmniType extension from the VS Code Marketplace, sign in with a free account, and open any project. The extension starts tracking immediately. Push a commit and your first provenance data appears in the dashboard within seconds.

Contact

Talk to us directly.

Questions, demos, integrations. You get a real answer.

Enterprise pricing
API access
Custom integration
General questions
Also in the OmniType suite
Pulse — our HR suite for attendance, leave & payroll.