GOAT-AI/gatcv6

GATC: Agentic Coding Sessions

Recorded sessions of AI coding agents at work, step by step.

• Website: goat.ai
• Full dataset and licensing: goat.ai/contact

This repository is a 1% sample. It holds 1,189 sessions, drawn uniformly at random from the 106,012 complete sessions of the full dataset of 117,796 sessions (complete: at least one user prompt and at least one agent reply; see Sampling). The figures on this page describe the full dataset unless a line says this repository. The full dataset has the same tables in the same format (JSONL, zstd-compressed).

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. Each session keeps the whole run in order: the user's messages, the agent's replies, every tool call with its arguments and, where the agent recorded one, its result, and the failed tool calls together with what the agent did next. Reasoning and token counts are included where the agent logged them.

About 41,000 of the 117,796 sessions are interactive: a person typed the prompts for their own work. They run long, so they hold about two-thirds of all steps and tool calls. The other sessions are agent runs on tasks that a script or another agent gave: evaluations, prepared tasks, exercises, batch jobs and sub-agents (see Composition).

Dataset Size

Count	Full dataset	This repository (1%)
trajectories (sessions)	117,796	1,189
steps	9,704,911	92,365
user prompts (user messages that are not automated wrapper text)	528,861	5,269
messages	117,796	1,189
sft_steps (tool calls)	5,751,020	52,617
error_recovery (failed tool calls)	240,957	2,028
labels	117,796	1,189
tool_grammar (tool names)	30	18

Composition

Interactive sessions, in which a person typed the prompts for their own work, are about 35% of all sessions (95% interval 32–38%). They run long, so most of the data is theirs:

	Full dataset	In interactive sessions (estimate)
Sessions	117,796	about 41,000 (35%)
Steps	9,704,911	about two-thirds (68%; 95% interval 66–70%)
Tool calls	5,751,020	about two-thirds (68%)

How this was measured: a language model reviewed a stratified sample of 360 sessions blind, in two passes that agreed on 96% of them, and the shares were weighted to the full dataset. Two checks that use no model point the same way: traces that only a person at the keyboard leaves, such as an interrupted reply, and the start mode that the agent tools themselves recorded. In this repository, about 475 of the 1,189 sessions are interactive (40%; higher than the full dataset's 35% because the sample is drawn from complete sessions only); the session_kind field marks 249 sessions interactive, those where the evidence is clear (see Taxonomy).

Highlights

• Session length. One in ten sessions has 166 steps or more and the longest has 36,656; the median is 26. One in ten lasts 1.6 hours or more (91,950 sessions record a duration).
• Multi-turn sessions. 38.1% of sessions hold two or more user prompts; 528,861 prompts in all. Automated wrapper messages (command output, notifications, interruption markers) are not counted.
• Tool use. 5,751,020 tool calls. Shell commands are 53.4% of them, reading files 14.3%, editing files 11.3%; 91,091 calls go to MCP servers, 99,088 hand work to a sub-agent and 14,318 invoke a skill.
• Failures are kept. 240,957 tool calls are recorded as failed (one in 24) and stay in place with the steps that followed; 12.5% of calls have no recorded result and are not counted as failed. In 85.5% of the failures a tool_call or retrieval step within the next four steps succeeded (the recovered flag; it does not check that the later call fixed the failure).
• Reasoning recorded. 571,504 reasoning steps across 26,107 sessions.
• Token accounting. Token counts as the agents reported them: 120.9B input tokens (reported by 95,759 sessions), 543.5B cache-read (81,346), 10.8B cache-write (58,939) and 1.8B output (95,752). Input and cache counts may be sums over model calls, so a context sent again on every call may be counted every time. Half of the sessions that report output tokens generated 2,355 or more.
• Breadth. 3,939 projects from 3,011 owners (pseudonyms; 10,362 sessions have neither). 60,382 sessions record the files they read, wrote or edited, 550,962 in all (each file counted once per session).
• Time span. 99% of the sessions with a start time began between February 2025 and September 2026; the latest on 22 September 2026.
• Model tiers. Sessions by the highest capability tier of the models they used: Tier S 4,887, Tier A 53,852, Tier B 25,450, Tier C 13,131, Tier D 5,061 (102,381 sessions use a model with a tier).

Token and Turn Statistics

Full dataset, by whether a session holds reasoning steps, and by the highest model tier a session used.

Metric	All sessions	With reasoning steps	Without reasoning steps
Sessions	117,796	26,107	91,689
Steps	9,704,911	2,925,556	6,779,355
Assistant messages	3,321,174	1,217,837	2,103,337
Tool calls	5,751,020	1,536,393	4,214,627
Failed tool calls (share of calls)	240,957 (4.2%)	71,991 (4.7%)	168,966 (4.0%)
Reasoning steps	571,504	571,504	0
Steps per session, mean (median)	82.4 (26)	112.1 (35)	73.9 (23)
Assistant messages per session, mean	28.2	46.6	22.9
Assistant replies per session (reasoning steps excluded), mean	23.3	24.8	22.9
Tool calls per session, mean	48.8	58.8	46.0
User prompts per session, mean	4.5	5.4	4.2
Sessions that report output tokens	95,752	22,385	73,367
Output tokens, total (those sessions)	1.78B	296.2M	1.48B
Output tokens per session, mean (median)	18,587 (2,355)	13,231 (1,974)	20,221 (2,468)
Output tokens per assistant message or tool call (ratio of totals)	240.5	135.3	284.7

Metric	Tier S	Tier A	Tier B	Tier C	Tier D
Sessions	4,887	53,852	25,450	13,131	5,061
Steps	471,757	5,526,735	1,944,092	592,867	195,101
Assistant messages	138,502	1,696,729	779,298	254,406	79,243
Tool calls	293,623	3,511,065	1,042,395	308,947	103,525
Failed tool calls (share of calls)	9,640 (3.3%)	117,982 (3.4%)	70,338 (6.7%)	27,774 (9.0%)	1,736 (1.7%)
Reasoning steps	43,841	312,982	118,247	33,704	100
Steps per session, mean (median)	96.5 (23)	102.6 (25)	76.4 (32)	45.2 (25)	38.5 (28)
Assistant messages per session, mean	28.3	31.5	30.6	19.4	15.7
Assistant replies per session (reasoning steps excluded), mean	19.4	25.7	26.0	16.8	15.6
Tool calls per session, mean	60.1	65.2	41.0	23.5	20.5
User prompts per session, mean	5.5	4.7	4.1	2.1	2.4
Sessions that report output tokens	4,704	50,606	21,598	11,990	4,603
Output tokens, total (those sessions)	197.2M	1.11B	306.3M	60.2M	50.0M
Output tokens per session, mean (median)	41,913 (2,976)	21,959 (2,040)	14,182 (2,702)	5,024 (1,429)	10,858 (6,500)
Output tokens per assistant message or tool call (ratio of totals)	473.5	241.0	203.9	120.5	291.8

Steps are all user messages, assistant messages and tool calls; an assistant message is an assistant step, a reply or a reasoning step, and a tool call is a step of type tool_call, retrieval or subagent. Output tokens are the counts the agent reported for the session; the token rows cover only the sessions that report them. The tier columns hold the sessions that used a model with a tier (102,381 of 117,796); a session counts under the highest tier it used.

Comparison with Other Datasets

How the release compares with the public datasets most similar to it: datasets that include sessions of people working with coding agents. Every cell was checked twice against each dataset's card, files or paper (October 2026); the second check was blind. ✓ means in most sessions, partial means partly or in a minority of sessions, ✗ means no. The Size column says what kind of session each dataset holds.

Dataset	Size	Tool-use trajectories	Failed calls labelled, with a recovery flag	Reasoning steps	Token counts	Code changes	Scanned before release⁸
SWE-chat (Baumann et al., 2026)	17,968 developer sessions	✓	partial¹	partial	✓	✓	partial
ACT-2.5B (anonymous, 2026)	183 developer sessions public (26,999 announced)	✓	partial¹	✓	✗	✓	✓
AgentLogs (Richards et al., 2026)	635,886 sessions of one agent working alone on tasks given through GitHub	✓	partial¹	partial	✓	partial²	✗
GATC (this dataset)	117,796 sessions: about 41,000 interactive³, the rest autonomous agent runs	✓	✓⁴	partial⁵	✓⁶	✓⁷	✓

¹ Failed calls carry a per-call label but no recovery flag (AgentLogs: in about 1% of sessions).

² Line counts and commit ids, not the changes themselves.

³ A person typed the prompts for their own work; see Composition.

⁴ Computed by us: a tool_call or retrieval step within the next four steps succeeded; it does not check that the later call fixed the failure.

⁵ 26,107 sessions (22%) hold reasoning steps.

⁶ Reported by 95,759 sessions (81%).

⁷ Edit and write calls carry the change itself (old and new text, the whole file, or the patch the agent applied), about nine in ten of them; there is no separate per-session diff or commit.

⁸ A scan of the released files with its result stated (for this dataset, see Release Gate); partial means that redaction tools are named but no result is stated.

Datasets of real sessions can overlap: some sessions appear in more than one of them, GATC included, so sizes do not add up. Session counts are as each dataset's card reports them. Datasets of agents run only on prepared tasks (such as NVIDIA's Open-SWE-Traces), of pull requests that agents opened, or of chats with an assistant are not listed.

Tables

Table	Description	Key
messages	Each session in the chat-message format (user, assistant with tool_calls, tool); reasoning steps are left out (they are in trajectories)	trajectory_id
trajectories	Each session step by step, with arguments, results, timing and the answering model's tier	trajectory_id
sft_steps	One row per tool call with the steps before it (shortened) and the call's result; the full history is in trajectories	(trajectory_id, i)
error_recovery	One row per failed tool call: the error, the next steps, whether a tool call among them succeeded	— (several rows per session; joins on trajectory_id)
labels	One row per session: step count, task type, session kind, key tools, files touched, metrics	trajectory_id
tool_grammar	One row per normalised tool: calls, sessions, failed calls	tool

Loading the Data

from datasets import load_dataset

# each table is a named config
messages = load_dataset("GOAT-AI/gatcv6", "messages", split="train")
trajectories = load_dataset("GOAT-AI/gatcv6", "trajectories", split="train")
sft_steps = load_dataset("GOAT-AI/gatcv6", "sft_steps", split="train")
errors = load_dataset("GOAT-AI/gatcv6", "error_recovery", split="train")
labels = load_dataset("GOAT-AI/gatcv6", "labels", split="train")

The dataset viewer on this page shortens long cells and marks the cut with ...TRUNCATED; the files hold every session in full (397 of the 1,189 messages rows are longer than 100,000 characters). A few tool calls contain ... [TRUNCATED] ... inside the text: the agent wrote that marker itself when it logged a large file.

Quick Examples

# the first user message of a session
first_message = next(m["content"] for m in messages[0]["messages"] if m["role"] == "user")

# sessions in which the agent called a write or edit tool
implementation = messages.filter(lambda r: r["task_type"] == "implementation")

# failed tool calls followed by a successful call within four steps
recovered = errors.filter(lambda r: r["recovered"])

# every shell command the agents ran, with its result
shell = sft_steps.filter(lambda r: r["tool"] == "bash")

# long sessions (100 steps or more)
long_sessions = labels.filter(lambda r: r["n_steps"] >= 100)

# sessions in which a person typed the prompts (where the evidence is clear)
interactive = messages.filter(lambda r: r["session_kind"] == "interactive")

# the agent's recorded reasoning, in the first session that has any
session = next(t for t in trajectories if any(s.get("thinking") for s in t["steps"]))
reasoning = [s["text"] for s in session["steps"] if s.get("thinking")]

Taxonomy

Task type (task_type, from the tools a session called; the rules apply in this order)

task_type	Rule	Sessions
implementation	a write or edit tool was called	53,516
exploration	otherwise, a read, grep, glob, list, web search or web fetch tool was called	23,167
conversation	otherwise, with at least one assistant message (shell commands may still run)	38,808

The remaining 2,305 sessions (2.0%) have no assistant message; their task_type is unknown.

Session length (n_steps, the exact number of steps)

Steps	Sessions
300 or more	5,842
100–299	14,912
20–99	47,247
fewer than 20	49,795

Session kind (session_kind, from evidence in the session itself)

session_kind	Meaning	Sessions
interactive	a person typed the prompts during the session	21,298
autonomous	no person typed the prompts: a script or a program, which can be another agent, started the session and gave the task	46,513
sub-agent	the transcript of a sub-agent, recorded by the agent tool as started by another agent; its prompt can quote the person's request	17,089
unknown	too little evidence either way	32,896

The evidence is the start mode the agent tool recorded (an interactive interface or a program), traces that only a person at the keyboard leaves (an interrupted reply, a refused tool permission, a slash command), the time a person took before the next prompt, task prompts that recur across owners, and known evaluation runs. A language model reviewed 1,224 sessions blind, in four review sets (the 360 of Composition among them), and judged whether a person typed the prompts. Of the reviewed sessions marked interactive, 98% (345 of 352) were judged person-prompted; of those marked autonomous, 97% (263 of 270) were judged not. The rules were chosen on these same reviews, so on other sessions the agreement is likely somewhat lower. A session is marked only where the evidence is clear, so the field marks 21,298 of an estimated 41,000 interactive sessions; most of the others are among the 32,896 unknown, about half of which are interactive.

Model tier (models per session, model per assistant step). Each model is shown as a capability tier: 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). Model names in the text are replaced by <MODEL_A>, <MODEL_B>…; a name that is also an everyday word can remain.

Dataset Schema

The schema of the files in this repository; the full dataset has the same tables, with a few more columns.

Relationship Map

trajectories (1) ──> (1) messages          [trajectory_id]
trajectories (1) ──> (1) labels            [trajectory_id]
trajectories (1) ──> (N) sft_steps         [trajectory_id; i = the step's index in trajectories.steps]
trajectories (1) ──> (N) error_recovery    [trajectory_id]
tool_grammar: one row per normalised tool, counted over the whole repository

ID Strategy

Entity	Key	Format	Notes
Session	trajectory_id	24 hex characters	a keyed hash; it cannot be turned back into the session's earlier id
Owner	actor_id	user<n>	pseudonym of the project's owner, the same in every session of that owner
Project	repo_id	repo<n>	pseudonym, the same for every session of one project
Project path	repo	user<n>/repo<n>	owner and project pseudonyms
Step	i	integer	0-based position in trajectories.steps

---

1. trajectories

Column	Type	Description
trajectory_id	string	PK
models	list[string]	the capability tiers of the models the session used
actor_id, repo_id, repo	string	pseudonyms (see ID Strategy)
started_at	timestamp	session start, UTC (written without a zone suffix); null when not recorded, and a few sessions hold a 1969 or 1970 placeholder date
duration_s	number	session duration in seconds; 0 when not recorded
n_steps, n_tool_calls, n_errors	int	steps, tool calls, failed tool calls
task_type	string	see Taxonomy
session_kind	string	interactive, autonomous, sub-agent or unknown (see Taxonomy)
tokens	object	token counts the agent reported: input, output, total, cache_read, cache_write; null or 0 when not reported
redaction	object	n: placeholders in the session
steps	list[object]	the session, step by step (below)
schema_version	string	gatc-v0.5

Steps (trajectories.steps[])

Field	Type	Description
i	int	0-based step index
type	string	user, assistant, tool_call, retrieval (read, search, fetch), subagent (work handed to a sub-agent)
text	string	user or assistant text
model	string	assistant steps: the answering model's tier
thinking	bool	true on a reasoning step
out_tokens	int	assistant output tokens
tool	string	normalised tool name (bash, read, edit, grep, write, mcp, …)
tool_raw	string	the tool name as the agent called it; in some sessions it repeats tool
tool_class	string	builtin, mcp, skill, task, other
mcp_server	string	for MCP tools, the server name
args	string	the call's arguments (usually JSON)
result	string	the call's result, where one was recorded
ok	bool	false when the call failed; null when no result was recorded
duration_ms	int	call duration
ts	string	step time, ISO 8601

2. messages

Column	Type	Description
trajectory_id	string	PK, FK -> trajectories
messages	list[object]	role (user, assistant, tool), content, tool_calls (id, type, function: name, arguments), tool_call_id
models, n_steps, task_type, session_kind		as in trajectories
actor_id, repo_id, repo	string	pseudonyms

3. sft_steps

Column	Type	Description
trajectory_id	string	FK -> trajectories
i	int	index of the tool-call step in trajectories.steps
context	list[object]	the up to 12 steps before the call (type, text; each text cut to about 600 characters)
tool, tool_raw	string	normalised and raw tool name (as in trajectories)
args	string	the call's arguments
result	string	the call's result, cut to about 4,000 characters (the full result is in trajectories)
ok	bool	whether the call succeeded; null when no result was recorded
actor_id, repo_id, repo	string	pseudonyms

Texts are cut before the last de-identification pass, so a placeholder added later can make a cut text slightly longer.

4. error_recovery

Column	Type	Description
trajectory_id	string	FK -> trajectories
failed_tool	string	normalised name of the tool that failed
args	string	the failed call's arguments
error	string	its result, cut to about 4,000 characters
recovery	list[object]	the next up to 4 steps (type, tool, text cut to about 800 characters)
recovered	bool	true when one of those steps is a tool_call or retrieval step that succeeded; it does not check that the failure was fixed
actor_id, repo_id, repo	string	pseudonyms

5. labels

Column	Type	Description
trajectory_id	string	PK, FK -> trajectories
n_steps	int	steps (the same as trajectories.n_steps)
task_type	string	as in trajectories
session_kind	string	as in trajectories
modified_files	list[string]	files the agent read, wrote or edited (de-identified paths, up to 100)
key_tools	list[string]	the session's most used tools (up to 8)
metrics	object	span_count (steps), llm_span_count (assistant steps), tool_call_count, error_count, error_rate, user_turn_count (user messages, automated wrapper messages included), distinct_files_touched (all distinct files; modified_files lists up to 100), distinct_models (tiers)
actor_id, repo_id, repo	string	pseudonyms

6. tool_grammar

Column	Type	Description
tool	string	PK, normalised tool name
calls, sessions, errors	int	calls, sessions that used it, failed calls
error_rate	number	errors / calls

Data Preparation

Normalisation

Every session is normalised into one schema whatever agent recorded it: steps in order, tool names mapped to a closed vocabulary, timing and token counts. A few tool names were replaced by placeholders during de-identification; they appear as their own rows in tool_grammar.

De-identification

People's names are replaced where the redactor finds them in an account, author or contact field, and then everywhere in that session; accounts, organisations, e-mail addresses, phone numbers, postal and network addresses and card numbers are replaced by typed placeholders stable within a session (<USER_n>, <USERNAME_n>, <NAME_n>, <PERSON_n>, <ORG_n>, <REPO_n>, <EMAIL_n>, <PHONE_n>, <ADDRESS_n>, <IP_n>, <IPV4_n>, <IPV6_n>, <MAC_n>, <HOST_n>, <CARD_n>, <ID>); secrets by <KEYBODY_n> or <REDACTED>; names of AI models and AI products by <MODEL_A>, <MODEL_B>…, and vendor names inside paths and identifiers by vendor_a, vendor_b…. Where a value could not be replaced safely, the text that held it was removed and marked <WITHHELD>: 48,000 places in 5,015 sessions. Names of third-party open-source projects and their owners, weak or default values in password fields, and names that are also ordinary words can remain; the residual risk is not zero. In this repository, names of owners' own projects, products and services, and of private persons, that recur in one owner's sessions and were confirmed by a review were replaced by <PROJECT_n>, stable within a session. A final audit in October 2026 scanned every string of this repository again, with open-source secret scanners (TruffleHog, gitleaks, detect-secrets) and scanners of our own, separate from the redactor and the release gate, and read the likely secrets among their findings in context. In 4 sessions it found secrets that the redactor and the gate had missed: API keys without a known prefix, pasted into prompts or written into commands and code; a password typed in a prompt; and session cookies in captured browser requests. They are now <KEYBODY_n>, and so is every run of 12 or more consecutive characters of them elsewhere in the same session, such as a truncated or line-wrapped copy.

Release Gate

Before release, a scanner written apart from the redactor read every data file of the full dataset: verdict PASS, 0 HARD findings over 117,796 sessions (HARD = release-blocking). The same scanner's findings from earlier scans drove the later masking rounds, so PASS shows that nothing this scanner detects remains; it is not an independent audit. Scanner self-test: on a separate test copy, it found all 1,657 synthetic secrets, identities and names planted there, and all 195 cases of its fixed regression set. This repository was scanned again on its own after the v2 changes: PASS, 0 HARD findings.

Deduplication Strategy

10,338 duplicate sessions were removed across the whole dataset: 2,586 when the sessions were first assembled, and 7,752 in later passes that matched exact copies, copies with the same content and near copies (MinHash).

Sampling

This repository: 1,189 sessions drawn uniformly at random from the full dataset's 106,012 complete sessions, those with at least one user prompt (a user message that is not automated wrapper text) and at least one agent reply. No stratum was given a quota, so the sample keeps the mix of the complete sessions up to sampling noise.

Limitations

• The data is pseudonymised, not anonymous: names that remain in the text, such as package or directory names, and the code itself can still point to its author.
• A person's name that appears only in free text (for example in a list of contacts) is not always detected; some remain.
• Recording is uneven across sessions: of the 117,796, input token counts are reported by 95,759, durations by 91,950 and start times by 106,502.
• There are no outcome labels, git commits or code attribution: nothing marks whether a session's task succeeded or which commits it produced.
• A few owners account for a large share of the sessions: the largest for 10.9%, the five largest for 28.0%.
• session_kind marks only clear cases: 32,896 sessions are unknown, and by the reviews about half of them are interactive.
• Part of the autonomous sessions are evaluation runs, and no decontamination against public evaluation sets was performed: check for overlap before you train or evaluate on them.
• Most user text is in English; some sessions are in other languages.

Data Removal Requests

To have a session removed, write to goat.ai/contact and quote its trajectory_id.

Versions

• v1 (8 Oct 2026): first public release of the 1% sample. (v6 in the repository name is a build number; gatc-v0.5 in schema_version is the schema version.)
• v2 (11 Oct 2026): messages and labels carry n_steps in place of the length band (tier, complexity; the model tier in models and model is unchanged); session_kind is added; more names of owners' own projects are masked, and so are the secrets found by the final audit (see De-identification). schema_version stays gatc-v0.5; v2 files are the ones with session_kind. If you downloaded v1, replace it with v2: v1 holds values that v2 masks.

License

This repository: Apache License 2.0 (LICENSE). The full dataset is licensed separately: goat.ai/contact.

Citation

@misc{goat_agentic_coding_sessions_2026,
  title        = {{GATC}: Agentic Coding Sessions},
  author       = {{GOAT labs}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/GOAT-AI/gatcv6}},
  note         = {Apache-2.0 for the 1\% sample}
}