Rytmely

// Guide

How to bill for work done by an AI agent

Your AI agents (Claude, Cursor, Codex) now produce part of your deliverables. This practical guide covers the honest questions that raises: should you bill for that time, how do you measure it, and how do you stay transparent with the client.

Start for free

No credit card

A new problem: billable work that stays invisible

Until recently, billable time at an agency or for a freelancer was easy to pin down: it was the time a human spent on a task, measured with a stopwatch. Autonomous AI agents blur that line. An agent that generates code, drafts a document, or analyzes a dataset produces real work with real value for the client, yet nobody keeps a record of it.

The result is an uncomfortable gray area. A growing share of your output runs through tools like Claude, Cursor, or Codex, but that work appears nowhere on your timesheets. You know it happened, you can see the deliverable, but you would struggle to say how much time it represented or how to value it.

So before we even talk about billing, there is a measurement problem to solve: making visible what is currently invisible. That is the prerequisite for making informed decisions afterward.

  • AI agent work is real and shipped to the client, but rarely tracked.
  • Without measurement, you cannot honestly decide whether to bill or absorb the cost.
  • The issue is not only financial: it also touches on transparency.

Should you bill a client for an AI agent's time?

There is no single answer, and it is important to say so honestly. Several models coexist, each with its trade-offs.

Billing by time treats the AI agent as one production resource among others: you measure processing time and add it to the count, possibly at a different rate than a human hour. This fits a classic hourly model, but it can lead to amounts that are hard to justify, since an agent can produce in minutes what would take a human hours.

Billing by fixed price or by value decouples the price from compute time. You bill for a deliverable or an outcome, regardless of how much an agent handled. This is often fairer for both sides, but it requires estimating value upfront, and it does not remove the need to measure time internally, if only to check your profitability.

  • By time: easy to fit into an hourly model, but sometimes hard to justify.
  • By fixed price or value: better aligned with outcomes, but needs solid estimation.
  • Either way, measuring time stays useful internally, even if you never re-bill it as-is.

How to measure an AI agent's time

Measuring human time is a long-solved problem: a stopwatch you start and stop. For an agent, the logic is the same, but the trigger has to be automatic. You are not going to ask a human to manually time what an AI does in the background.

This is where the MCP protocol (Model Context Protocol) comes in. It lets an AI agent talk to external tools, including a time tracker. In practice, the agent can call functions like start_timer at the beginning of a task and stop_timer at the end, with no human intervention. Time is captured at the source, reliably.

Rytmely exposes a native MCP API built for exactly this. The agents you already use log their time automatically, attached to the right assignment. For the sake of honesty: Rytmely is not the first to offer MCP-based time tracking — tools like TrackingTime and Timely already do it in English. Rytmely's distinction is being MCP-native and available in French, on a still-emerging topic.

  • MCP lets an agent start and stop its own timer.
  • Time is captured automatically, with no after-the-fact manual entry.
  • Rytmely is MCP-native and French-first, without claiming to have invented the approach.

How to add that time to an invoice

Once time is measured, you still have to decide how it shows up on the invoice. Two broad options, depending on your client relationship and positioning.

A dedicated line item explicitly shows the work done by the AI, separate from human time. It is the most transparent option: the client sees precisely what an agent produced and at what rate. It can also become a selling point if you position AI use as an efficiency gain you pass along.

Silent integration folds agent time into an overall service without breaking it out. This is not dishonest in itself, especially if you bill a fixed price and the deliverable is what matters. But as soon as the client pays by time, not specifying the nature of the billed time becomes a problem. The simple rule: the more your billing is tied to time, the more visible the human/agent distinction should be.

  • Dedicated line: maximum transparency, the AI appears as an identified item.
  • Bundled integration: acceptable on fixed price, risky on hourly billing.
  • The Client → Project → Label structure makes for a clean, invoice-ready export.

Ethics and transparency at stake

Beyond the amount, the real issue is trust. A client who later discovers that a large share of their deliverable was produced by an AI, when they thought they were paying for entirely human work, can feel misled, even if the result is excellent.

The most durable position is proactive transparency: stating upfront that you use AI agents in your production, explaining what it brings, and being clear about how it is billed. This turns a risk of distrust into a demonstration of expertise.

There is also the question of what an agent's time is worth. Billing an hour of agent work at the rate of a human expert hour is hard to defend. Many prefer to bill the value of the deliverable, or apply a specific rate reflecting that this is supervised machine time, not human time. What matters is choosing a logic and being able to explain it.

  • Proactive transparency protects the client relationship better than silence.
  • Announcing AI use upfront can become a mark of professionalism.
  • An agent's time deserves its own pricing logic, distinct from the human hour.

The tooling: MCP and the Client → Project → Label structure

For all of this to be manageable day to day, you need a tool that captures time automatically and files it in a usable way. That is the job of a time tracker built for AI agents.

Rytmely structures every time entry across three levels: the Client, the Project, and the Label (the nature of the task). Whether a timer is started by a human or by an agent via MCP, it attaches to the same hierarchy. You get a unified view of human and agent time on a single assignment.

In practice, an agent calls start_timer on a given project, works, then calls stop_timer. Time accumulates in the right place, distinguishable from human time, and exportable to feed your billing. The data is hosted in Europe and GDPR-compliant, which matters when you track activity tied to your clients.

  • Structured tracking by Client → Project → Label, humans and agents in one view.
  • Agent timers driven by MCP (start_timer / stop_timer), no manual entry.
  • Time exportable for billing, European hosting compliant with GDPR.

// FAQ

Frequently asked questions

Make your AI agents' time visible

Rytmely automatically captures your agents' time via MCP and files it by Client, Project, and Label, ready to export for billing. Hosted in Europe, GDPR-compliant.

Start for free