GATC-S: Frontier-Model Agentic Coding Sessions

Recorded sessions of AI coding agents running on frontier flagship models, step by step.

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

This repository is a sample of 100 sessions. The full GATC-S dataset holds 4,317 sessions: every complete session of GATC (goat.ai/gatc, 117,796 sessions) whose recorded models are all frontier flagship models (Tier S). The 100 are balanced across the dataset's four model families (see Sampling). The figures on this page describe the full GATC-S dataset unless a line says this repository. The full dataset has the same tables in the same format (JSONL, zstd-compressed).

Dataset Summary

GATC-S is a dataset of recorded sessions of AI coding agents working on software tasks, in which every model a session recorded is a frontier flagship model (Tier S). It is drawn from GATC, our larger corpus of agentic coding sessions (goat.ai/gatc), and keeps only its complete sessions of that kind; it was 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 1,200 of the 4,317 sessions are interactive: a person typed the prompts for their own work. They run long, so they hold about two-thirds of the steps. Most of the other sessions are evaluation runs.

Dataset Size

Count	Full dataset	This repository
trajectories (sessions)	4,317	100
steps	240,485	7,702
user prompts (user messages that are not automated wrapper text)	15,634	534
messages	4,317	100
sft_steps (tool calls)	136,482	4,444
error_recovery (failed tool calls)	5,026	92
labels	4,317	100
tool_grammar (tool names)	16	16

Highlights

• Session length. The median session has 20 steps; one in ten has 128 or more; the longest has 2,859. The median recorded duration is 1.7 minutes; one in ten lasts 1.5 hours or more (4,239 sessions record a duration).
• Multi-turn sessions. 28.3% of sessions hold two or more user prompts; 15,634 prompts in all. Automated wrapper messages (command output, notifications, interruption markers) are not counted.
• Tool use. 136,482 tool calls. Shell commands are 51.3% of them, editing files 15.3%, reading files 11.0%; 6,095 calls go to MCP servers, 2,454 hand work to a sub-agent and 1,858 invoke a skill.
• Failures are kept. 5,026 tool calls are recorded as failed (one in 27) and stay in place with the steps that followed; 3.4% of calls have no recorded result and are not counted as failed. In 89.1% 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. 35,566 reasoning steps across 1,610 sessions (37.3%).
• Token accounting. Token counts as the agents reported them: 486.6M input tokens (reported by 4,187 sessions), 21.1B cache-read (4,124), 460.0M cache-write (2,750) and 89.0M output (4,210). 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,616 or more.
• Breadth. 228 projects from 194 owners (pseudonyms; every session has both). 2,296 sessions record the files they read, wrote or edited, 17,146 in all (each file counted once per session).
• Time span. All but two of the 4,310 sessions with a start time began between November 2025 and September 2026; the latest on 21 September 2026.
• Models. Every model a session recorded is a Tier S model (frontier flagship), from four model families; 342 of the 82,853 assistant steps carry no model of their own.

Token and Turn Statistics

Full dataset, by whether a session holds reasoning steps.

Metric	All sessions	With reasoning steps	Without reasoning steps
Sessions	4,317	1,610	2,707
Steps	240,485	102,511	137,974
Assistant messages	82,853	54,374	28,479
Tool calls	136,482	42,229	94,253
Failed tool calls (share of calls)	5,026 (3.7%)	1,961 (4.6%)	3,065 (3.3%)
Reasoning steps	35,566	35,566	0
Steps per session, mean (median)	55.7 (20)	63.7 (38)	51.0 (9)
Assistant messages per session, mean	19.2	33.8	10.5
Assistant replies per session (reasoning steps excluded), mean	11.0	11.7	10.5
Tool calls per session, mean	31.6	26.2	34.8
User prompts per session, mean	3.6	2.9	4.0
Sessions that report output tokens	4,210	1,533	2,677
Output tokens, total (those sessions)	89.0M	23.4M	65.6M
Output tokens per session, mean (median)	21,150 (2,616)	15,261 (3,662)	24,522 (1,493)
Output tokens per assistant message or tool call (ratio of totals)	423.1	256.3	550.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.

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. GATC-S is the part of GATC in which every recorded model is a frontier flagship model (Tier S), so both rows are shown.

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	117,796 sessions: about 41,000 interactive³, the rest autonomous agent runs	✓	✓⁵	partial⁶	✓⁷	✓⁸	✓
GATC-S (this dataset)	4,317 sessions, the Tier S part of GATC: about 1,200 interactive⁴, most of the rest evaluation 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: about 35% of GATC's sessions (95% interval 32–38%), holding about two-thirds of its steps, by a blind review of a stratified sample by a language model, with two checks that use no model pointing the same way. ⁴ About 27% of GATC-S sessions (95% interval 22–33%), by the same kind of review; they hold about two-thirds of its steps (69%; 95% interval 65–71%). ⁵ 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. ⁶ GATC: 26,107 sessions (22%) hold reasoning steps; GATC-S: 1,610 (37%). ⁷ GATC: reported by 95,759 sessions (81%); GATC-S: by 4,187 (97%). ⁸ Edit and write calls carry the change itself (old and new text, the whole file, or the patch the agent applied): in GATC about nine in ten of them, in GATC-S 99%; 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-S 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: length band, task type, 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/gatc-s", "messages", split="train")
trajectories = load_dataset("GOAT-AI/gatc-s", "trajectories", split="train")
sft_steps = load_dataset("GOAT-AI/gatc-s", "sft_steps", split="train")
errors = load_dataset("GOAT-AI/gatc-s", "error_recovery", split="train")
labels = load_dataset("GOAT-AI/gatc-s", "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 (22 of the 100 messages rows are longer than 100,000 characters).

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["complexity"] in ("A_premium", "A_long_weak_label"))

# 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	1,659
exploration	otherwise, a read, grep, glob, list, web search or web fetch tool was called	957
conversation	otherwise, with at least one assistant message (shell commands may still run)	1,701

Length band (tier in trajectories and messages, complexity in labels; this is not the model tier)

Band	Steps	Sessions
A_long_weak_label	300 or more	178
A_premium	100–299	364
B_standard	20–99	1,650
C_bulk	fewer than 20	2,125

The band names come from an internal scheme and mark length only, not quality.

Model tier (models per session, model per assistant step). Every model in GATC-S is shown as Tier S, the frontier flagship models; an assistant step with no model of its own has model null. 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 GATC-S dataset has the same tables and 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 one session holds a 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
tier	string	length band (see Taxonomy)
task_type	string	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, tier, task_type		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
complexity	string	length band (same as trajectories.tier)
task_type	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

Selection

GATC-S holds every session of GATC that is complete (at least one user prompt and at least one agent reply) and whose models list is exactly Tier S, that is, every model the session recorded is a Tier S model: 4,317 of GATC's 117,796 sessions. GATC was deduplicated before the selection (10,338 duplicate sessions removed; see goat.ai/gatc).

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>: 452 places in 105 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 also replaced, by <PROJECT_n>, stable within a session.

Release Gate

A small subset puts a handle on fewer owners than the whole corpus does, so GATC-S and this repository each got one more masking round of their own: the handles that a subset this small concentrates on a few owners, and a few account ids, were replaced by typed placeholders. Each was then read in full by a scanner written apart from the redactor: PASS, 0 HARD findings (HARD = release-blocking), over all 4,317 sessions of GATC-S and, separately, over the 100 sessions of this repository. The same scanner's findings drove the 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.

Sampling

This repository: 100 sessions of GATC-S, none of them in GATC's public 1% sample, balanced across the dataset's four model families: 27 sessions from each of three families and all 19 sessions of the fourth that are outside that 1% sample, in a seeded random order within each family. The two smallest families together hold under 3% of GATC-S, so this sample over-represents them; the figures above describe the dataset's own mix.

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.
• GATC-S comes from 194 owners and 228 projects; the largest owner accounts for 37.1% of the sessions and the five largest for 73.8%, so figures per session lean towards their way of working.
• Recording is uneven across sessions: of the 4,317, input token counts are reported by 4,187, durations by 4,239 and start times by 4,310.
• There are no outcome labels, git commits or code attribution: nothing marks whether a session's task succeeded or which commits it produced.
• The files do not mark which sessions are interactive (about 1,200 of the 4,317; in this repository, 22 of the 100). Most of the other 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 (9 Oct 2026): first public release of the 100-session sample. (gatc-v0.5 in schema_version is the schema version.)

License

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

Citation

@misc{goat_gatc_s_2026,
  title        = {{GATC-S}: Frontier-Model Agentic Coding Sessions},
  author       = {{GOAT labs}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/GOAT-AI/gatc-s}},
  note         = {Apache-2.0 for the 100-session sample}
}