A 0–100 score across five components, computed from your last 30 days of Claude Code, OpenAI Codex, and Cursor transcripts plus your public GitHub commit history. Leverage (60 pts — agent leverage + longest agent run), Craft (18 pts — six anti-patterns: coding without a plan, revert rate, repetitive prompts, rage quits, auto-compaction rate, redundant approvals), Customization (7 pts — skill / MCP / plugin volume × reuse depth), Output (10 pts — commits + lines changed), and Efficiency (5 pts — cost per commit). See the metrics page for every definition.

Under 60 seconds to install. Under 60 seconds to your first score. You install the skill with one command — gh skill install https://github.com/flatironconsulting/conductorscore conductorscore --agent claude-code --scope user --force — which writes it into ~/.claude/skills/conductorscore/. Running /conductorscore links this machine via GitHub device flow, scans 30 days of your JSONL on-device, and uploads numbers-only to the server. The scan itself takes ~47 seconds for ~140 sessions.

No. The client is a pure function from JSONL events to per-session structural inputs — about 38 fields per session: integers, booleans, 16-char SHA-256 hash prefixes, timestamps, tool names, model IDs. No paths. No message text. No tool arguments. No code. The wire format is in our public client repo; server CI fails if the schema drifts. Our data inspectorshows every field the client can send, field-by-field, with a sanitized example payload. Don't take our word for it — Claude independently audited the client against this policy, tracing every byte that leaves the machine and running its own leak probe.

Yes. The skill ships a local session viewer: ask it to "visualize this session" (or run session_viewer.pydirectly) and it renders that session's HITL / AFK / Tool / Idle timeline, leverage table, and subagent panels as a self-contained HTML page — entirely on your machine, nothing uploaded. It's redacted by default (hashes + counts only, so the page is safe to share); add --no-redactto see the real transcript text. It reuses the same classifier that produces your score, so the bars you see match the numbers you're scored on.

Two steps. (1) Raw measurement — your client computes the raw value for each metric on-device. (2) Anchored mapping — the server maps each raw value to points using a documented log-normalized threshold (e.g. 7× total leverage saturates at full points; an anti-pattern below its "penalty-free" threshold contributes zero penalty). The seven scored sub-metrics sum to a 0–100 score across five components: Leverage (60 pts), Craft (18), Customization (7), Output (10), and Efficiency (5). All thresholds are published in the live methodology page.

The client is fully open: github.com/flatironconsulting/conductorscore. Python stdlib only — zero dependencies. The wire format and schema live there as the source of truth. The scoring algorithm is server-side (so we can re-score historical data when the algorithm changes), but the inputs the server receives are spelled out in the public client repo. For a worked example, read Claude's independent audit — it clones the repo, traces every egress path, and verifies nothing but numbers, hashes, and categorical labels crosses the wire.

Some inputs are easier to inflate than others. Customization rewards volume, but the depth factor cancels window-dressing — install 50 skills and use each once and you score zero depth. Output (commits, lines changed) can be padded, but it's capped at 10 points. The behavioral signals — longest agent run, revert rate, auto-compaction rate, rage quits, cost per commit — are hard to fake because they reflect what actually happened. The composite sums points across five components, so gaming any single sub-metric barely moves the dial. Server-side anti-gaming checks (bounds, monotonicity, dimension floors) are coming.

Claude Code, OpenAI Codex, and Cursor sessions are all scanned and scored today.ConductorScore reads each agent's local session data on your machine — ~/.claude/projects/ for Claude Code, ~/.codex/sessions/for Codex, and for Cursor both the IDE's globalStorage/state.vscdb and the CLI's ~/.cursor/chats/**/store.db. Adapters for OpenCode and Cowork are coming. The metrics normalize across a shared event stream so the dashboard shape stays the same.

All three agents are scanned and scored today. How completely each scored signal is covered depends on what the agent writes to disk locally — here's the current map.

● Full · ◐ Partial · ○ Not yet

1. Cursor CLI sessions don't store per-turn timestamps; we reconstruct timing from each turn's embedded timestamp tag, so CLI leverage is approximate. Cursor IDE timing is exact.
2. Codex 0.14+ runs shell inside a JavaScript cell. We extract git commands conservatively (literal calls only), so Codex commit and revert counts can under-count when a command is built dynamically.
3. Cursor doesn't record a context-compaction event we can read from local storage.
4. Skill attribution differs by agent: Claude exposes explicit skill markers, Codex is inferred from SKILL.md reads, and Cursor doesn't attribute skills per session on-device.
5. Cursor stores only context-window token estimates on disk — not the billed input/output/cache tokens (available only via Cursor's Admin API) — so cost-per-commit isn't scored for Cursor yet.
6. Cursor's "Auto" routing writes a placeholder model name; we recover the real routed model from the CLI transcript where it's present.

Not automatically. ConductorScore scores the detailed, turn-by-turn session transcripts each agent writes to disk locally, and cloud runs don't drop those on your machine the way local runs do. Codex Cloud tasks execute on OpenAI's infrastructure; the CLI can list tasks and apply their diffs, but there's no way to pull a task's full session log down locally — it remains an open feature request on OpenAI's own repo (codex#24777). Claude Code on the web runs in Anthropic-managed VMs instead of locally. You can pull an individual web session down with claude --teleport, which does write its JSONL into ~/.claude/projects/ — and since our scanner reads the whole file, it would score it. Full support for Claude Code on the web is coming — we're building automatic, lossless scoring of your cloud sessions so you don't have to teleport them one by one. Codex Cloud will follow once OpenAI ships a way to export task logs locally.

Individual scoring is free and stays free forever — broad adoption is what makes the score meaningful. Team dashboards and tamper-evidence (coming soon) are where we'll charge. Free during the public beta regardless.

Every paired account gets a public profile — there's no toggle. Your profile lives at conductorscore.com/u/yourhandle and shows your score, grade, percentile, per-component breakdown, and 30-day activity. The leaderboard ranks public profiles by composite score, recomputed nightly. The auto-rendered OG card is what your shared links look like on X/LinkedIn.

No transcript data does. The extractor is a pure function on-device; the server receives only the numeric and categorical fields documented in WIRE_FORMAT.md in the public client repo. The data inspector shows every field the client can send, with a sanitized example payload — designed to clear enterprise security review. To hand your security team a head start, Claude's independent audit planted secrets in every leak-prone position and confirmed none reach the upload.

Your dashboard breaks your score into the five components and flags your single biggest opportunity — the component with the most points still on the table — with a short, actionable nudge and the exact point lift available (e.g. "Leverage is your biggest opportunity … +16 points still on the table"). The breakdown is the product; the composite is just the headline.

For hiring: ask candidates to include their ConductorScore profile URL with their application. The privacy model maps to enterprise security reviews. For team mode: team leaderboards with rolled-up metrics (coming soon) — for early-access pilots, email hello@conductorscore.com.