Problem: AI projects in business get judged by the number of agents launched or tasks processed, which says nothing about whether people got time back, and hides the time someone spends checking the output. Result: a small calculation of weekly hours freed per task that counts review time explicitly. Stack: Python 3.10+ standard library (tested on 3.15.2). Boundaries: you supply the minutes; the example numbers are invented for one imaginary employee
Why this metric
The ads promise a hundred agents running a company. When I tried building real systems, the useful ones turned out to be narrow, repetitive and checked by a person. I run a team of 8 AI agents; none of them runs the business alone, and none publishes or spends without me. My personal agent has been running for 134 days, does 10 scheduled jobs and has passed 165 tasks to other bots since July, with deleting, spending, client messages and publishing always waiting for my yes
The scale is real, but it shows up as hours, not as agent counts. A post that took about an hour now reaches a preview in about 5 minutes; a long call becomes a transcript, tasks and a CRM card in about 10 minutes. Measuring that honestly means counting the review step too
Input, processing, output
Input: per task, how many times a week it happens, minutes per item before AI, minutes per item after AI, and minutes a person spends reviewing each AI result
Processing: hours before equals count times minutes before; hours after equals count times (minutes after plus review); freed equals the difference
Output: hours before, after and freed per task, plus a weekly total
The example
def freed_hours(before: dict, after: dict, review_minutes: dict, per_week: dict) -> list[tuple]:
"""Weekly hours freed per task, counting the time a person spends checking AI output."""
rows = []
for task, n in per_week.items():
old = before[task] * n / 60
new = (after[task] + review_minutes[task]) * n / 60
rows.append((task, round(old, 1), round(new, 1), round(old - new, 1)))
return rows
if __name__ == "__main__":
# invented teaching numbers for one employee's week
per_week = {"invoice check": 40, "weekly report": 1, "client reminders": 30}
before = {"invoice check": 6, "weekly report": 90, "client reminders": 3}
after = {"invoice check": 0.5, "weekly report": 5, "client reminders": 0.2}
review = {"invoice check": 1.5, "weekly report": 20, "client reminders": 0.5}
total = 0
for task, old, new, freed in freed_hours(before, after, review, per_week):
total += freed
print(f"{task}: {old} h -> {new} h, freed {freed} h/week")
print(f"total freed: {round(total, 1)} h/week")
Output, exactly as printed when I ran it:
invoice check: 4.0 h -> 1.3 h, freed 2.7 h/week
weekly report: 1.5 h -> 0.4 h, freed 1.1 h/week
client reminders: 1.5 h -> 0.3 h, freed 1.1 h/week
total freed: 4.9 h/week
Note how review dominates "after" in every row. That is not a flaw; it is the part a person keeps, and leaving it out would overstate the gain several times over
Design notes
Review is not optional. In every working chain I run, the last decision is human. If your "after" number has no review time, either the work is truly trivial or nobody is checking it
Measure, do not estimate. Time a normal week before the change and a normal week after. Guesses about manual work are usually low, and guesses about review are usually lower
Freed hours need a destination. Decide with the employee what the time goes to: more customers, better quality, postponed work. Otherwise it dissolves into the week and nobody can say what changed
Bad metrics are easy to grow. Agents, runs and generated texts can all go up while freed hours stay flat. Track hours first
Choosing tasks to measure
Three questions filter candidates: does the task repeat, can its result be checked, and is there a named person to check it. If any answer is no, pick another task. Repetitive operations such as order processing, report preparation and individual steps in finance and bookkeeping usually pass; complex multi-step judgement usually does not
Where freed time should go
The calculation is only useful if the hours land somewhere. In practice they go to more customers, because the same person answers more people and stops losing leads; to quality, because a specialist finally has time to think; to work that was postponed for months; or simply to fewer late evenings. Write the destination next to the number. If there is nowhere to put the time, that is a conversation about where the business wants to grow, not a reason to cut someone
Limits
Small numbers mislead. A task done twice a week will never free much time, however good the AI is
Quality is outside this calculation. A faster process that produces worse work is not a win; keep a separate check on output quality
Ramp-up skews the first weeks. Review takes longer until corrections turn into rules; measure again after a month
Reproduce it
- Save the code as
hours.pyand runpython3 hours.py - Replace the dictionaries with one real employee's tasks and measured minutes
- Rerun after a month with updated review times
- Write down where the freed hours went
The non-technical version: AI for business problems: scale without firing people
This article was created with the help of AI.



Top comments (0)