GOAT-AI/gatc-workload-1w

GATC Workload: A One-Week Trace of Agentic Coding Sessions

One week of recorded sessions of AI coding agents as a systems trace: timing, tools, outcomes and tokens, with no text.

• Website: goat.ai/gatc
• Full dataset and licensing: goat.ai/contact
• Email: yerbol@goat.ai

This repository is a text-free trace of one week of GATC. It holds 883 sessions (136,283 steps) from 107 owners and 118 projects, with ids of its own. The full GATC dataset, with the de-identified text of every session (this week's included), is licensed separately: goat.ai/contact.

At a Glance

• What it is. 883 of the 1,067 sessions that started in one calendar week (see Selection), each kept whole and in step order, on one shared clock; no text of any kind.
• Built for systems work. Sandbox scheduling (keep warm or hibernate), capacity planning, tool latency and concurrency: per step its type, tool, outcome, time, duration and token counts; per session its start, end, counts and flags.
• Concurrency. At each minute of the week (days 0–6 of the clock) a median of 17 sessions are open (max 38), from a median of 14 owners; a median of 2 have a tool call running (max 10).
• Open is not busy. Over the sessions with recorded durations, tool calls cover 11.3% of open time, and 82.8% of the idle time between tool calls lies in gaps longer than 30 minutes.
• Ready to filter. is_subagent marks 168 sub-agent runs and is_eval 50 prepared evaluation tasks; duration_resolution marks the 37 sessions with three or more tool durations, all in whole seconds.
• Ids of its own. session_id, user_id and repo_id are assigned afresh for this repository and do not correspond to the ids of other GATC releases (see ID Strategy).

Dataset Summary

GATC (GOAT AI Trajectory Corpus) is a dataset of recorded sessions of AI coding agents working on software tasks, collected, curated and de-identified by GOAT labs (goat.ai/gatc). It holds 117,796 sessions; its public 1% sample is GOAT-AI/gatcv6. This repository holds one calendar week of it as a systems trace for research on agent workloads. Its 883 sessions are 82.8% of those that started that week (see Selection), and they share one clock, so you can see which sessions and owners were open at the same time. It holds no text of any kind: no prompts, no code, no diffs, no tool output.

The agent is the software that ran a session and recorded it. The owner is GATC's owner of the session's project: an account, not necessarily one person.

Dataset Size

Count	This repository
sessions	883
steps	136,283
user steps (prompts and wrapper messages)	6,367
assistant steps (replies and reasoning steps)	22,309
tool calls (steps of type tool_call, retrieval or subagent)	107,607
failed tool calls (tool_ok false)	1,720
model calls with token counts	72,587
owners / projects	107 / 118

Highlights

Percentiles on this card are nearest-rank; the median of an even count is the mean of the two middle values, rounded half up.

• Concurrency. Counted as in Activity and Idle, at each whole minute of days 0–6 (see The Clock). Open sessions: median 17, 90th percentile 29, max 38. Owners with an open session: median 14, 90th percentile 21, max 25. Sessions with a tool call running: median 2, 90th percentile 3, max 10. Without the sub-agent and evaluation sessions, open sessions: median 16, 90th percentile 28, max 37.
• Tool latency. Over the 741 sessions with millisecond durations, a tool call takes a median of 738 ms (90th percentile 24,874 ms). The table under 1. steps gives each tool.
• Failures are kept. 1,720 tool calls (1.6% of all, 1.8% of those with a recorded outcome) are recorded as failed and stay in place with the steps that followed.
• Token accounting. 72,587 model calls carry token counts, in 652 sessions (73.8%). Cache reads are 90.8% of their input tokens.
• Composition. 168 sessions are sub-agent runs, from 7 owners, and 50 are prepared evaluation tasks, from 2 owners. The other 665 are neither. 233 sessions have no user step: 43 sub-agent runs and 190 of the other 665.

Tables

Table	Description	Key
steps	One row per step: type, normalised tool, outcome, time, duration, token counts, model tier	(session_id, step_index)
sessions	One row per session: owner, project, start, end, counts and flags	session_id

Loading the Data

from datasets import load_dataset

# each table is a named config
steps = load_dataset("GOAT-AI/gatc-workload-1w", "steps", split="train")
sessions = load_dataset("GOAT-AI/gatc-workload-1w", "sessions", split="train")

The steps are in data/steps.parquet, ordered by session start (ties in a fixed order), then step_index. The sessions are in data/sessions.parquet, in the same order. jsonl/steps.jsonl and jsonl/sessions.jsonl hold the same rows as JSON Lines.

Quick Examples

The examples use pandas; the hf:// paths need huggingface_hub, and dtype_backend="pyarrow" keeps integer columns with nulls as integers.

import pandas as pd

base = "hf://datasets/GOAT-AI/gatc-workload-1w/data/"
steps = pd.read_parquet(base + "steps.parquet", dtype_backend="pyarrow")
sessions = pd.read_parquet(base + "sessions.parquet", dtype_backend="pyarrow")

# sessions open at each whole minute of days 0-6 (start <= t < end): median 17, max 38
iv = sessions.dropna(subset=["end_rel_ms"])
open_now = pd.Series([((iv.start_rel_ms <= t) & (t < iv.end_rel_ms)).sum() for t in range(0, 7 * 86_400_000, 60_000)])
print(open_now.median(), open_now.max())

# sessions that are neither sub-agent runs nor prepared evaluation tasks: 665
own = sessions[~sessions.is_subagent & ~sessions.is_eval]
print(len(own))

# clock day (Monday = 0) and hour of each step; UTC is up to an hour ahead of the clock (see The Clock).
# pyarrow integer columns have no %, so only // is used
day = steps.t_rel_ms // 86_400_000
hour = steps.t_rel_ms // 3_600_000 - 24 * day

# tool calls, and their median duration per tool over the sessions with millisecond durations (the tool table's
# medians; the card rounds a half up)
tools = steps[steps.step_type.isin(["tool_call", "retrieval", "subagent"])]
ms_sessions = sessions.session_id[sessions.duration_resolution.isin(["ms"])]
print(tools[tools.session_id.isin(ms_sessions)].groupby("tool_verb").duration_ms.median())

# idle gaps between consecutive tool calls of a session: 92,992, 7,636 of them 0, 924 longer than 10 minutes
tools = tools.sort_values(["session_id", "step_index"])
prev_end = (tools.t_rel_ms + tools.duration_ms).groupby(tools.session_id).shift()
gap = (tools.t_rel_ms - prev_end).clip(lower=0).dropna()
print(len(gap), (gap == 0).sum(), (gap > 600_000).sum())

# the idle-timeout table: cold starts beyond each session's first, idle hours kept warm
for m in (1, 5, 10, 30, 60):
    print(m, (gap > m * 60_000).sum(), round(gap.clip(upper=m * 60_000).sum() / 3_600_000, 1))

# the model calls, one row each: 72,587
calls = steps[steps.in_tokens.notna() | steps.out_tokens.notna()]

Dataset Schema

The schema of the files in this repository.

Relationship Map

sessions (1) ──> (N) steps          [session_id; step_index = 0-based position in the session]
sessions (N) ──> (0..1) sessions    [parent_session_id -> session_id: a sub-agent run's parent, if in this repository]

ID Strategy

Entity	Key	Format	Notes
Session	session_id	24 hex characters	a keyed hash of the session's GATC id, keyed for this repository only: it matches no session id of other GATC releases and cannot be turned back into one
Owner	user_id	user<n> (1 … 107)	pseudonym of the session's owner, the same in every session of that owner; every session has one
Project	repo_id	repo<n> (1 … 118)	pseudonym of the session's project, the same in every session of that project; every session has one
Step	step_index	integer	0-based position in the session; (session_id, step_index) is unique

user_id and repo_id are numbered in the order of each one's first session start (start_rel_ms), independently of other GATC releases: user12 here and user12 there need not be the same owner.

---

1. steps

Column	Type	Description
session_id	string	FK -> sessions (see ID Strategy)
user_id, repo_id	string	the session's owner and project (see ID Strategy)
harness	string	always agentic-harness; it carries no information (the agent software is not named)
step_index	int	0-based position in the session; with session_id, the PK
step_type	string	user, assistant, tool_call, retrieval (read, search, fetch) or subagent (work handed to a sub-agent); the last three are tool calls
tool_verb	string	tool calls: the normalised tool name, one of GATC's 17 (the tool of other GATC releases; table below); other stands for any tool the other 16 do not name; null for user and assistant steps
tool_ok	bool	tool calls: success (true) or failure (false) as the agent recorded it; null when it recorded neither (13,533 calls, 1,140 of which returned output)
t_rel_ms	int	the step's time on the clock (see The Clock): when the agent recorded the step, or for a tool call when the call was made; null when no time was recorded (2,777 steps)
duration_ms	int	tool calls: milliseconds from the call to its result; null when not recorded (13,889 calls). GATC writes 0 for a missing duration, so a 0 becomes null and no value is 0
in_tokens	int	input tokens of the model call that produced this step, prompt-cache reads and writes included (the whole context sent); set on the first step of each call, null on its others (see Tokens)
out_tokens	int	output tokens of that model call, reasoning included
model_band	string	assistant steps: the model tier (below); null when no model was recorded or its tier is unknown
exit_code	int	bash calls: the exit status the agent printed with the output; null when it printed none (see Outcomes)
cached_in_tokens	int	the part of in_tokens read from the prompt cache; null wherever in_tokens is null, and where the agent's log has no cache split for the call (6 calls)

Calls by tool, over all sessions (failed: tool_ok false). The durations are over the 741 sessions with millisecond durations (duration_resolution = ms).

Tool	Calls	Sessions	Owners	Failed	Duration median (ms)	90th percentile (ms)
bash	67,602	723	92	1,013	1,194	29,995
read	11,624	504	71	114	19	174
other	8,206	333	57	52	811	48,932
edit	7,183	283	63	128	35	1,206
grep	3,352	147	25	34	66	764
web_fetch	1,880	149	22	135	6,234	11,828
task	1,845	160	46	56	2,305	60,120
write	1,794	288	62	45	44	1,719
mcp	1,387	50	25	76	1,345	6,891
glob	768	102	19	19	49	152
list	494	78	5	6	8	16
todo	405	53	14	0	3	492
web_search	393	112	23	21	5,205	8,304
search_tools	248	168	32	0	8	164
ask_user	217	94	43	17	62,739	445,499
skill	147	52	29	4	63	203,529
finish	62	28	1	0	1	3

retrieval steps are read, grep, web_fetch, glob, list and web_search; every subagent step is task; the other 10 tools are tool_call steps.

Model tier (model_band): GATC's capability tier of the answering model, assigned by model family and generation, not by a benchmark score: Tier S frontier flagship models, Tier A frontier models, Tier B workhorse models, Tier C small and fast models, Tier D legacy models (earlier generations). Assistant steps: Tier S 325, Tier A 8,681, Tier B 4,958, Tier C 3,136, Tier D 0; null 5,209 (no model recorded, or a model of unknown tier).

2. sessions

Column	Type	Description
session_id, user_id, repo_id	string	PK (session_id); user_id and repo_id as in steps (see ID Strategy)
start_rel_ms	int	the session's start: the earlier of its recorded start and its earliest step time; never null
end_rel_ms	int	the latest end of any of its steps (a tool call ends at t_rel_ms + duration_ms, other steps at t_rel_ms); null when no step has a time (15 sessions)
n_steps	int	its rows in steps
n_tool_calls	int	its tool calls
n_failures	int	its tool calls with tool_ok false
max_context_tokens	int	its largest in_tokens; null when none of its model calls has token counts
is_eval	bool	true when GATC flags the session as a prepared evaluation task (50 sessions); not exhaustive (see Limitations)
is_subagent	bool	true when the session is a sub-agent's own run (168 sessions): GATC links it to its parent (10), its timing ties it to a subagent step of another session (2), or the agent recorded it as started by another agent, with no parent known (156)
parent_session_id	string	FK -> sessions: the parent's session_id, when GATC links the session to its parent or timing ties it to one, and the parent is in this repository (12 sessions, all with is_subagent true); null otherwise
has_tokens	bool	true when at least one of its steps has in_tokens or out_tokens (652 sessions)
has_durations	bool	true when at least one of its tool calls has duration_ms (782 sessions)
duration_resolution	string	s when it has 3 or more recorded tool durations and all are whole seconds (37 sessions); ms when at least one is not (741); null otherwise (105)

Workload

The Clock

t_rel_ms, start_rel_ms and end_rel_ms share one clock: milliseconds since the earliest session start in this repository. t_rel_ms = 0 falls between 00:00 and 01:00 UTC on a Monday, so UTC day d (Monday = 0) begins within the hour before t_rel_ms = d × 86,400,000. Day of week and hour of day (UTC) can therefore be read off the clock to within an hour; no time zone is recorded. On this card, day d runs from t_rel_ms = d × 86,400,000 up to (d + 1) × 86,400,000. The files hold no date, and this card gives no exact offset.

21 sessions ran on after the week.

In 31 sessions the agent recorded times to the whole minute only. Each of these sessions is shifted as a whole by an unpublished amount under one minute, so that they do not reveal the clock's exact offset. Their intervals are as recorded; their times, and so their order against other sessions, are accurate only to about a minute. They are not flagged, but all step times of such a session share one remainder modulo 60,000 ms; that test also catches one other session with two or more step times.

Activity and Idle

A session is open from start_rel_ms to end_rel_ms (start ≤ t < end), that is, from its first to its last recorded time. The 15 sessions with no end_rel_ms, and the 7 whose end equals their start, are never open. A tool call runs from t_rel_ms for duration_ms. A call with no duration_ms never runs, so the running counts are a lower bound, and the 101 sessions with no recorded durations never count as running. The concurrency figures (see Highlights) count both at every whole minute of days 0–6 (t_rel_ms a multiple of 60,000).

Open is not busy. A session's first and last recorded times can be days apart: open spans have a median of 17 minutes and a 90th percentile of 8.6 hours. The 32 sessions open longer than a day hold 55.8% of the open-session minutes of days 0–6. Counting only the sessions open a day or less gives median 6, 90th percentile 17, max 28.

The figures below model one sandbox per session, busy only while a tool call runs and idle in the gaps between tool calls. A gap runs from the end of one tool call (t_rel_ms + duration_ms) to the start of the next, in step order. It is 0 when the next call starts before that end. No gap is counted after a call with no recorded duration. A gap is within a turn when no user step lies between the two calls, and across turns when one does. Since user steps include wrapper messages (see Normalisation), a wrapper message also ends a turn. Over the 782 sessions with recorded durations:

• Tool calls cover 11.3% of the sessions' open time: the sum of duration_ms over the sum of end_rel_ms − start_rel_ms, with overlapping calls each counted in full.
• Of the tool-call time, bash is 57.8%, other 17.7%, ask_user 11.1% and task 5.8%. These figures count every tool as busy, including ask_user, which waits for a person, and task, which runs a sub-agent whose own run may also be a session in this repository. Without ask_user, tool calls cover 10.0% of the open time. Leave out the tools that your scheduler would not run in the sandbox.
• A few long calls weigh heavily: the 29 calls longer than an hour hold 28.7% of the tool-call time, and one ask_user call of more than a day 8.2% (without it, ask_user is 3.2% of the tool-call time).
• There are 92,992 gaps, 7,636 of them 0. 96.7% fall within a turn and 3.3% across turns; the within-turn gaps hold 44.0% of the idle time.
• In the 233 sessions with no user step, every gap counts as within a turn; they hold 36.9% of all idle time. In the other 549, within-turn gaps hold 11.2% of those sessions' idle time.
• 82.8% of the idle time lies in gaps longer than 30 minutes.
• A 10-minute idle timeout would cause 924 cold starts beyond each session's first (one per gap longer than 10 minutes), in 249 of the 782 sessions, 3.7 in each of those on average. Of the 924, 401 fall within a turn (353 of them in sessions with no user step) and 523 across turns.

Other timeouts trade cold starts against idle time kept warm: each gap is kept warm up to the timeout, and a gap longer than the timeout costs one cold start. Over the same 782 sessions, with 2,883.6 idle hours in all (gaps between calls only):

Idle timeout	Cold starts	Idle hours kept warm
1 min	4,245	269.1
5 min	1,510	421.0
10 min	924	518.1
30 min	440	715.4
60 min	281	880.4

Tokens

in_tokens and out_tokens come from the usage the agent logged for each model call. They sit on the first step the call produced; the other steps of the same call have null. That step is usually the tool call the model asked for, not an assistant step (60,352 of the 72,587 rows with counts are tool calls), so select the rows with in_tokens or out_tokens set to get one row per model call. in_tokens is set on all 72,587 of them; 6 of them have neither out_tokens nor cached_in_tokens, and the rest have both. A model call has no start time and no column gives model latency, but its row always has a t_rel_ms (all 72,587), the time of the first step the call produced: bin these rows by time for the model-side load. model_band is set on assistant steps only, so 12,235 of the call rows carry a model tier.

Some agents log the output count repeatedly while the reply streams; out_tokens keeps the largest count logged for the call. 1,867 of the 72,581 out_tokens values are 10 or less. A logged 0 is set to null (123 input and 129 output counts): agents log 0 for messages they produce without a model and in records left incomplete.

Across the model calls, in_tokens has a median of 146,345 and a 90th percentile of 369,749. Over the 652 sessions with counts, max_context_tokens has a median of 153,805 and a maximum of 1,010,667.

cached_in_tokens is the part of in_tokens read from the prompt cache. Unlike in_tokens and out_tokens, it keeps a logged 0, as a cache miss is a real value: 68,567 of its 72,581 values are above 0.

Outcomes

exit_code is set on 767 of the 67,602 bash calls, 714 of them non-zero. Several agents print the status only when a command fails, so a null exit_code does not mean success. In one session the agent recorded no bash call as failed, whatever its exit status: 3 calls there have a non-zero exit_code with tool_ok true.

No session ends on a failed tool call. Of the 1,720 steps that directly follow one, 811 are tool_call, 308 retrieval, 46 subagent, 484 assistant and 71 user; 56.0% are a call of the same tool, and 12.7% are a failed tool call again.

Data Preparation

Selection

This repository is one calendar week of GATC, from Monday 00:00 UTC to the next Monday 00:00 UTC. A session belongs to the week when its earliest recorded time falls in it: 1,067 sessions, 0.91% of GATC's 117,796. Left out are the 69 of them that other GATC samples already publish or share, and 115 sessions tied to one of those. A session is tied to a left-out one when it is in the same sub-agent family (a parent session and its sub-agent runs, linked in GATC or by timing), or when it has the same owner and started within 30 seconds of it, ran back to back with it (one starting within five minutes of the other's end), or one of the two started just after a sub-agent call of the other. Tied sessions were left out with their own sub-agent families; see De-identification for why. 883 sessions remain. Sessions that started before the week are not here, even where they ran into it; sessions that started in it are kept whole, however long they ran.

This repository is limited to under 1% of GATC's sessions. A whole week keeps together the sessions that ran at the same time, apart from those left out above; a random sample would split them. Owners often ran sessions side by side: 583 of the 868 sessions with a start and an end (67.2%) overlap another session of the same owner; counting only the 650 that are neither sub-agent runs nor evaluation tasks, 410 (63.1%) do. The week is not a random or typical one: of the 103 calendar weeks under that limit, it is one of the 6 with more than 100 owners.

Normalisation

Every session is normalised into one GATC schema, whatever agent recorded it: steps in order, with the step types user, assistant, tool_call, retrieval and subagent, and tool names mapped to GATC's closed vocabulary of 17 normalised tools (tool_verb). As in GATC, user steps include wrapper messages (command output, notifications, interruption markers) and assistant steps include reasoning steps; this repository marks neither.

De-identification

This repository holds no text. Every string is an id, a pseudonym or a value from a closed vocabulary, at most 24 characters long; no value holds a date, an e-mail address, a URL or a path. Times are relative (see The Clock).

The date is withheld, and the sessions that other GATC samples hold were removed together with the sessions tied to them, to keep this trace from being lined up with those samples; the residual risk is not zero.

Of the 107 owners, 27 also appear in GATC's public 1% sample under other pseudonyms. In a linkage test, up to 3 of them could be matched to their sessions there by their habits and session flags. We ask that you not use this repository to re-identify people or to link owners or sessions across releases.

Release Gate

Before upload, a check script separate from the build read every data file of this repository: closed schema, no text, no dates, and none of the strings @, http, /, def and import in any value. From the GATC records it recomputed week membership, every step's type, tool, outcome, duration, model tier and time, every session's evaluation and sub-agent flags and parent link, and the id mappings; it checked token counts and exit codes for consistency only. Verdict: OK. The check and the build come from the same team, so OK shows that nothing the check tests for remains; it is not an independent audit.

Limitations

• The data is pseudonymised, not anonymous. An owner's working pattern (hours, tools, session lengths) can still point to them, and the week's date, though not released, could be inferred. Some owners also have sessions, with text and dates, in GATC's public samples (27 of them in the 1% sample; see De-identification).
• A few owners account for a large share: the owner with the most sessions holds 10.9% of them and 17.9% of the tool calls, and the five with the most sessions hold 40.3% of the sessions and 34.0% of the tool calls (3 of the five mostly through sub-agent runs or evaluation tasks). The five owners with the most tool-call time hold 66.4% of it. Figures per session, and the concurrency, lean towards their way of working.
• Owners are accounts, and an account can run many sessions at once: 4 owners (2 counting only sessions that are neither sub-agent runs nor evaluation tasks) have 10 or more sessions open in the same minute. Read the concurrency as these owners' activity, not as the load of any service.
• 17.2% of the sessions that started in the week were left out (see Selection), and not at random: among them are whole sub-agent families and same-owner sessions started together with, or just before or after, a left-out one. The open-session and running-call counts are therefore lower than the week's own, and an owner's parallel and consecutive sessions are the most under-counted.
• Sessions that started before the week are not here. Many sessions stay open for days, so this lowers the open-session counts all through day 0 (median 10, against 16–18 on days 1–5 and 26 on day 6), and on later days too, if less: 37.2% of the open-session minutes of days 3–6 belong to sessions that had started more than 24 hours earlier (26.3% more than 48 hours).
• The trace holds what the agents logged, not data on the machines they ran on: there are no CPU, memory or container figures, and the sandbox in Activity and Idle is a modelled one.
• Recording is uneven across sessions: of the 883, token counts are logged by 652, tool durations by 782 and step times by 868.
• One week only, and not a typical one (see Selection): Saturday (day 5) has the most session starts and tool calls, and the two weekend days hold 39.8% of the tool calls of days 0–6.
• is_eval is GATC's flag of a prepared evaluation task, set in GATC from the text of the session's first prompt (markers of evaluation tasks, and openings shared by groups of sessions that a review classed as evaluations). It is not exhaustive, and this repository does not hold the text it was computed from. GATC links a sub-agent run to its parent when the parent's sub-agent call's prompt equals the run's first message, under the same owner; is_subagent without a known parent means the agent recorded the session as started by another agent.
• The latency figures (the duration percentiles in Highlights and the tool table) are over the 741 sessions with duration_resolution = ms; Activity and Idle uses all 782 sessions with recorded durations. The 37 s sessions record whole seconds only (4.2% of the recorded tool durations), which raises the percentiles of short calls: leave them out for latency work.
• Sub-agent work appears as subagent steps in the parent session. Where a sub-agent's own run was also recorded, it is a separate session with is_subagent true (168 sessions); leave these out when counting owners' sessions. parent_session_id links one to its parent only when the parent is known and in this repository: 12 of the 168.
• Values are as the agents recorded them, except that the 31 minute-precision sessions are shifted (see The Clock) and logged zero in_tokens and out_tokens are null (see Tokens). The 2 parent links that timing ties are inferred; no missing value was filled in.
• Step times are as recorded: in 31.1% of the sessions (275) a step's time is earlier than the previous timed step's (1,328 steps in all).
• Calls an agent issued in parallel are separate rows, one after another; nothing groups them.

Data Removal Requests

To have a session, or every session of an account, removed, write to goat.ai/contact: quote the session_id, or name the account, so that we can find its sessions in GATC.

Versions

• v1 (27 Oct 2026): first public release.

License

This repository: Creative Commons Attribution 4.0 International (CC BY 4.0), unlike the other public GATC releases (Apache License 2.0). To attribute it, cite it as below, link the license and say whether you changed the data. The full dataset is licensed separately: goat.ai/contact.

Citation

@misc{goat_gatc_workload_1w_2026,
  title        = {{GATC} Workload: A One-Week Trace of Agentic Coding Sessions},
  author       = {{GOAT labs}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/GOAT-AI/gatc-workload-1w}},
  note         = {CC BY 4.0}
}