Skip to content

How AtoAxis calculates coding time

AtoAxis derives coding time from editor heartbeats. Nearby evidence becomes a duration block; a long or trailing gap stays outside the total.

What a heartbeat proves

A heartbeat is an event from a connected editor. It can include a timestamp, file and project metadata, branch, language, editor and activity counts. It describes observed editor activity; it does not prove that every minute spent planning, reading or talking produced coding time.

  • The timestamp places the event on the account timeline.
  • Metadata lets the same interval be filtered by project, language, branch or editor.
  • Counts and attribution fields remain separate from the duration calculation.

From events to duration blocks

AtoAxis canonicalises overlapping evidence first, then orders the remaining intervals. The duration of a block is the union of its intervals, so two sources cannot count the same seconds twice. A single isolated event proves an instant but does not invent a long session after it.

Illustrative timeline
09:00 interval ───── 09:05 interval ───── 09:10 interval
          one continuous duration block

How idle gaps are handled

The default human idle timeout is 15 minutes. When two proven intervals are separated by a positive gap no longer than that timeout, the gap is bridged to the earlier interval, matching the WakaTime-compatible session model. A gap longer than the configured timeout closes the block. The timeout is configurable per deployment, so the deployed setting is the source of truth.

  • A short gap between two real events can be included in the earlier block.
  • A gap longer than the timeout starts a new block instead of padding the old one.
  • Time after the final event is never added just because the session was once active.
  • Agent activity can use its own timeout when that deployment enables the split timeline.

Worked example

Illustrative example, not customer data: suppose an interval ends at 09:00 and the next begins at 09:10. With the default 15-minute timeout, that 10-minute gap is bridged. If the next interval begins at 09:30, the 20-minute gap is too long, so the first block ends and a second block begins. Time after the final interval remains uncounted.

Worked example
09:00 ──(10 min gap)── 09:10    bridged
09:10 ──(20 min gap)── 09:30    new block

The arithmetic explains the rule, not a promise about a particular dashboard total. Check the timeline and its interval evidence when a total looks surprising.

How to read the result

  • Coding time is observed editor activity, not all time spent on a task.
  • A duration total does not measure code quality, value, focus or productivity.
  • Use project, language, branch and editor filters to find which evidence produced a total.
  • Compare the duration with the activity timeline and coverage fields before drawing a conclusion.

Verify your first total

Connect one editor, run wakaclock-cli status, make a small change and wait for the first heartbeat. The dashboard timeline should show the event and the Overview page should use the same duration model. If it does not, check the API key, server URL and local queue before adding another client.

Review owner: AtoAxis product team. Last reviewed: 20 September 2026.

How does AtoAxis turn heartbeats into coding time?

Nearby heartbeats become duration blocks. A gap no longer than the 15-minute default idle timeout is bridged; a longer or trailing gap stays outside the total.

A 30-second tour recorded from this website: the time-ring overview, the Human + AI split, the AI coding tracker and planned pricing.

Key takeaways

Evidence:
A heartbeat is an event from a connected editor with metadata and counts.
Blocks:
Overlapping evidence is merged, so two sources never count the same seconds.
Idle timeout:
The default human idle timeout is 15 minutes.
Trailing gap:
Time after the last event is not counted.

How do you check a total that looks surprising?

Illustrative example, not customer data: an interval ends at 09:00 and the next begins at 09:10. The 10-minute gap is bridged. If the next interval had begun at 09:30, the 20-minute gap would stay outside the total, because it is longer than the 15-minute timeout.

How to read coding activity metrics
SignalWhat it supportsWhat it cannot prove
Editor heartbeatsRecorded coding activityAll working time
Attributed changesReported source of changesCode quality or time saved
This comparison separates what the data supports from conclusions it cannot establish.

Recommendation

Open the timeline for the day in question and read the interval evidence before assuming a total is wrong. Run wakaclock-cli status first if no heartbeat appears at all, then check the editor connection.

Trade-offs to weigh

On the other hand, any timeout rule is a model of activity. A long pause spent reading code ends a block even though you were working, and a short gap between unrelated edits is still bridged.

“A metric that cannot be established should say so instead of rendering as zero.”

— Jitwisut Thobut, Founder & developer, AtoAxis

Sources and review

Written and reviewed by , Founder & developer of AtoAxis. Reviewed . Product claims describe our implementation; examples are illustrative, not customer research.

Coding time FAQ

Does AtoAxis count time after my last heartbeat?

No. A trailing gap after the final observed event is not added to the duration total.

What is the default idle timeout?

The default human timeout is 15 minutes. A deployment can configure it, so check the deployed setting when comparing totals.

Does a heartbeat include my source code?

No. Heartbeats carry activity metadata and counts; source code, prompts and responses are outside the payload.

Is coding time a productivity score?

No. It is a record of observed editor activity and should be read with its limits and coverage.