Quick Answer
LinearB reads your forge, your CI and your issue tracker. It measures how a pull request moved through the pipeline, splits cycle time into coding, pickup, review and deploy, and then automates the review workflow itself with gitStream. DevClocked measures the sessions that produced the pull request, including terminal work and AI agent runs, and ties token cost to what shipped. If your problem is that PRs sit in review for three days, buy LinearB. If your problem is that you cannot tell what your agents did with those three days, DevClocked.
At a glance
| DevClocked | LinearB | |
|---|---|---|
| Main data source | Session telemetry from editor and terminal, plus a git baseline | Git, PR, CI and issue-tracker metadata |
| Unit of measurement | The work session | The pull request |
| Core metric | Leverage Score, output per unit of effort | Cycle time and DORA |
| AI agent tracking | Claude Code, Codex CLI and Cursor as first-class sessions | AI adoption correlated against PR and commit data |
| Token and cost tracking | Yes | Not a stated feature |
| PR workflow automation | No | gitStream, a real strength |
| Chat alerts and nudges | No | WorkerB for Slack and Teams |
| Smallest team it fits | One developer | 30 billable contributors minimum |
| Pricing | See pricing | $29 or $59 per contributor per month |
What LinearB does well
LinearB is the tool I would reach for to diagnose a slow delivery pipeline, and I am not going to pretend otherwise. Its cycle-time model is the clearest in the category. It splits the trip from first commit to production into coding time, pickup time, review time and deploy time, so a team arguing about "we're slow" stops arguing and finds out PRs wait nine hours before anyone opens them. LinearB publishes elite benchmarks per phase, under one hour of pickup time and under 19 hours of total cycle time among them, so you get a target rather than a number floating in space. The DORA reporting is mature and has been for years.
gitStream is the part with no DevClocked equivalent, and it is why plenty of teams buy LinearB. It is a workflow automation engine configured by YAML files that live in the repo, and it auto-assigns reviewers, labels PRs by risk, triggers the right CI jobs, and auto-merges low-risk changes like docs and dependency bumps. It is Apache-2.0 licensed and free on its own. LinearB claims over 200 million PRs processed through it.
WorkerB pushes PR reminders, review requests and team risk alerts into Slack or Microsoft Teams. Enterprise adds resource allocation, investment profiles and R&D cost capitalization, which matter enormously if finance needs a defensible split of engineering spend and not at all if they do not. Integration breadth is strong across GitHub, GitLab, Bitbucket, Azure DevOps, Jira and Azure Boards.
Where DevClocked is different
LinearB sees the pull request once it exists, and it sees how that PR travelled. It cannot see the hours or the agent runs that produced it. That is the whole gap.
Sessions, not pull requests. DevClocked's unit is the work session. It builds an approximate baseline from git, corrects it with telemetry from a lightweight editor extension and an editor-agnostic CLI tracker, then calibrates the two over time. Git alone cannot tell you how long anything took, so we do not claim it can. A session record captures the two hours of debugging behind a nine-line diff. PR metadata never sees it.
Agent runs as first-class objects. Claude Code, Codex CLI and Cursor sessions are tracked as their own work, with AI-versus-human attribution on the output. LinearB measures AI adoption by correlating activity against commits and PRs, which answers "is the team using it" but not "what did this run cost and produce". Start with measuring AI adoption across a team if that is your question.
Token cost against shipped output. DevClocked tracks tokens and cost and puts them next to what landed. You cannot reconstruct that from a forge.
Work that never becomes a PR. Spikes, abandoned branches, incident firefighting, prompting an agent down a path you then discard. None of it shows up in cycle time. All of it shows up in a session record.
Leverage over throughput. The Leverage Score is output relative to effort, a different question from how fast a PR clears review. Shared workspaces, org dashboards and leverage benchmarking sit on the Business tier, described on teams.
Feature by feature
| Feature | DevClocked | LinearB |
|---|---|---|
| DORA metrics | No | Yes, mature |
| Cycle-time phase breakdown | No | Yes, its signature |
| PR workflow automation | No | gitStream, free and open source |
| Slack and Teams alerts | No | WorkerB |
| Investment profile, cost capitalization | No | Yes, Enterprise tier |
| Forge, CI and issue-tracker integrations | Focused | Very broad |
| Session-level time attribution | Yes | No |
| AI agent runs as first-class sessions | Yes | Adoption signals from PR and commit data |
| Token and cost tracking | Yes | Not a stated feature |
| Usable by a single developer | Yes | 30-contributor minimum |
Pricing
LinearB lists two paid tiers. Essentials is $29 per contributor per month, minimum 30 billable users, capped at 5 admins, GitHub Cloud only, with 1,000 monthly credits. Enterprise is $59 per contributor per month, minimum 50 billable users, unlimited admins, 1,500 credits, and adds resource allocation and investment profiles, R&D cost capitalization, on-prem agents, project forecasting and the wider set of git and issue-tracker integrations. There is a 45-day trial with no payment method required.
The seat minimums are the number to watch. A team of eight still pays for 30 seats on Essentials, so entry cost is roughly $870 a month whatever your headcount. LinearB has offered a free plan for small teams in the past and the current pricing page does not show one, so verify current pricing before you budget against it. gitStream on its own stays free and open source, which is worth knowing if the automation is the only part you want.
DevClocked prices per seat with no floor, and one developer can install it today. Current numbers are on pricing.
Who should pick which
Pick LinearB if your bottleneck is the delivery pipeline. PRs sitting unreviewed, cycle time you cannot explain, a board that wants DORA, a finance team that wants a capitalization report, or a review process you want to automate rather than only observe.
Pick DevClocked if you want to know what agent-assisted sessions produced and what they cost. Per-session and per-agent granularity, token spend against shipped output, and the work that never turns into a pull request. It works for one person or a team of five, which LinearB currently does not.
Run both if you have the budget and both problems. LinearB for pipeline flow, DevClocked for what happened inside the sessions feeding it.
Verdict
LinearB is good at the thing it is for. The cycle-time breakdown is the clearest diagnostic in the category, gitStream is genuinely useful and genuinely free, and the DORA and investment reporting hold up in front of a finance team. If pipeline flow is your problem, stop reading comparison pages and go buy it.
It is also blind to everything before the pull request. It cannot tell you how long a session ran, which agent did the work, or what the tokens cost, because none of that reaches a forge. That is the measurement DevClocked exists for. For the wider category map, see software engineering intelligence platforms and the Waydev comparison.
FAQ
Only for part of the job. DevClocked does not do DORA reporting, cycle-time phase analysis or PR workflow automation. It replaces LinearB for teams who bought it hoping to measure AI-assisted work and found the PR-level view too coarse, or for small teams who found it heavier and pricier than the problem justified.
It tracks adoption by correlating activity against pull request and commit data across a large set of AI tools, and reports the effect on delivery metrics. It does not record the agent session itself or the tokens it burned. DevClocked treats Claude Code, Codex CLI and Cursor runs as sessions with their own duration, cost and attributed output.
No. gitStream assigns reviewers, labels PRs by risk and auto-merges safe changes. DevClocked has nothing equivalent and no plans to. gitStream is free and open source, so run it alongside DevClocked without paying LinearB anything.
Both answer half. LinearB shows whether cycle time and throughput moved after adoption. DevClocked shows what each agent run cost and produced. The honest version needs both, and there is more in engineering productivity metrics.
Probably not at the current seat minimums, since you would pay for 30 contributors. Take gitStream on its own for the automation, and engineering team time tracking if the question is where the hours went. If you do want a full platform at that size, compare DX and Swarmia too.