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
• Email: yerbol@goat.ai

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).

At a Glance

• What it is. 4,317 sessions, each kept whole and in order, de-identified and scanned before release.
• Who drove them. About 1,200 of the 4,317 sessions are interactive (see Dataset Summary). session_kind marks 672 of them where the evidence is clear.
• Ready to filter. is_eval flags 2,506 sessions of prepared evaluation tasks; template_group_size counts the GATC sessions that open with the same prompt; is_wrapper marks wrapper text (command output, notifications) among user messages.
• Ready to train. messages keeps each assistant turn's text, reasoning and tool call together, with arguments mapped onto a per-tool schema, and each session carries the schemas of its tools in tools; 3,789 sessions have no ft_issues.
• Facts about outcomes. 424 sessions record a test runner's last verdict (last_test_result: 379 passed, 45 failed) and 398 a commit that git confirmed (git_commit_made). These are records of what the tools printed, not success labels.
• AI agents evaluating this dataset: start with AGENTS.md: what the files hold, how to load them and check the main counts of this repository, and which features are design choices rather than defects.

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 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)	17	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. Wrapper messages (command output, notifications, interruption markers) are not counted.
• Tool use. 136,482 tool calls. Shell commands are 52.3% of them, editing files 15.5%, reading files 11.4%; 6,095 calls go to MCP servers, 2,462 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 status (ok is null; 49.5% of them still hold a 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).
• Evaluation runs flagged. 2,506 sessions (58.0%) are prepared evaluation tasks (is_eval, eval_kind): question batteries 1,602, terminal tasks 832, other evaluations 65, exercises 7. 3,128 sessions open with a prompt that ten or more GATC sessions share (template_group_size).
• Languages. First prompts by language (prompt_language): English 4,011, Chinese 62, German 16, Japanese 16, Portuguese 8, Russian 7, Korean 6, Spanish 4; 177 sessions have too little prose to tell.
• Sub-agents linked. 32 of the 349 sub-agent sessions name the session that started them (parent_trajectory_id).
• 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); the table shows both.

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 complete sessions of GATC in which every model is Tier S: 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) where it was recorded: in messages, 79.7% of them in GATC and 96.9% in GATC-S hold it in normalised form, and the others keep a shape no rule maps or recorded only the file path or nothing; 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, built for training: an assistant turn holds its text, its reasoning and at most one tool call with arguments mapped onto the tool's schema; the session's tool schemas in tools	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 or retrieval step among them succeeded, and which (recovery_kind)	— (several rows per session; joins on trajectory_id)
labels	One row per session: step count, task type, session kind, evaluation flag, template group, language, test and commit facts, 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")

Each config declares its features, so load_dataset and the viewer read every column. The dataset viewer on this page shortens long cells and marks the cut with ...TRUNCATED; the files hold every session in full (26 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-tool call with its result (`messages` names these `bash`, `exec`, `bash_input`, …)
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")

# drop prepared evaluation tasks and rows with anything listed in ft_issues
train = messages.filter(lambda r: not r["is_eval"] and not r["ft_issues"])

# sessions whose last test run passed
tests_passed = labels.filter(lambda r: r["last_test_result"] == "passed")

# 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")]

Fine-tuning

messages follows the chat format of tool-calling models. arguments and tools are JSON strings (one Arrow column cannot hold tool schemas that differ between sessions), so parse them before a chat template sees them:

import json
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(MODEL)  # MODEL: the tool-calling model you fine-tune

def chat(row):
    msgs = []
    for m in row["messages"]:
        m = {k: v for k, v in m.items() if v is not None and k != "is_wrapper"}
        if m.get("tool_calls"):
            m["tool_calls"] = [{**tc, "function": {**tc["function"], "arguments": json.loads(tc["function"]["arguments"])}}
                               for tc in m["tool_calls"]]
        msgs.append(m)
    return msgs, json.loads(row["tools"])

msgs, tools = chat(messages[0])
text = tokenizer.apply_chat_template(msgs, tools=tools, tokenize=False)

Every session of this repository renders without error through the chat templates of two open tool-calling model families. Sessions are long: rendered with one of them, the median session is 9,734 tokens, and 23 sessions are over 32,768 (9 over 131,072); split or window long sessions to fit a context length. Chat templates differ in what they keep of reasoning_content: in this check one family's kept it for 47.2% of the turns that have it and the other's for none.

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

Session length (n_steps, the exact number of steps)

Steps	Sessions
300 or more	178
100–299	364
20–99	1,650
fewer than 20	2,125

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

session_kind	Meaning	Sessions
interactive	a person typed the prompts during the session	672
autonomous	no person typed the prompts: a script or a program, which can be another agent, started the session and gave the task	2,788
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	349
unknown	too little evidence either way	508

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 GATC sessions blind, in four review sets (GATC-S sessions 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. These rates are over all the reviewed sessions, not GATC-S alone, and 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 672 of an estimated 1,200 interactive sessions (about 27% of the 4,317; 95% interval 22–33%); most of the others are among the 508 unknown.

Evaluation tasks (is_eval, eval_kind)

eval_kind	Sessions
qa-battery	1,602
terminal-task	832
other-eval	65
exercise	7

A session is flagged when its first prompt carries a marker of a prepared evaluation task, or when it opens like a template that a review classed as an evaluation: the 500 largest groups of identical openings were reviewed by a language model, those ranked 151 to 500 twice and independently, both verdicts having to agree. In a blind check of 78 sessions of the GATC 1% sample, drawn by stratum, all 50 flagged sessions were evaluation tasks and 7 evaluation tasks were not flagged; a one-off task with no marker stays unflagged. The markers were refined on this check, so on other sessions recall may be lower.

Template groups (template_group, template_group_size). Sessions of GATC (117,796 sessions, which GATC-S is drawn from) whose first prompt opens with the same 160 characters (letter case, digits and placeholder numbers ignored; openings of 32 characters or more) share a group; the size counts them, so a size can exceed the number of GATC-S sessions. Scripted runs repeat their opening; people rarely do.

Prompt language (prompt_language, ISO 639-1), detected on the first prompt after code, paths and URLs are cut; null when too little prose is left.

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 model family name without a version, or one 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 (none here); in GATC-S, 7 sessions have none and 1 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
task_type	string	see Taxonomy
session_kind	string	interactive, autonomous, sub-agent or unknown (see Taxonomy)
is_eval, eval_kind	bool, string	a prepared evaluation task, and its kind (see Taxonomy); null kind when false
template_group, template_group_size	string, int	the group of GATC sessions that open the same way, and its size; null and 1 for a unique opening, null and null for a short one or none
parent_trajectory_id	string	a sub-agent session's parent: its sub-agent call's prompt equals this session's first message (placeholder numbers aside), same owner; null otherwise (it can name a session outside this repository)
prompt_language	string	ISO 639-1 language of the first prompt; null when too little prose
last_test_result	string	passed or failed: the last call that ran a test runner, read from the runner's summary; null when none ran or it cannot be read
git_commit_made	bool	a git commit call that git confirmed
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
is_wrapper	bool	user steps: wrapper text (command output, notifications, interruption markers), not a prompt
model	string	assistant steps: the answering model's tier; null when no model was recorded (37 of 2,427 assistant steps here)
thinking	bool	true on a reasoning step
out_tokens	int	assistant output tokens
tool	string	normalised tool name (bash, read, edit, grep, write, mcp, …); other for a tool outside the vocabulary, whose own name is in tool_raw
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 as the agent recorded them (usually a JSON object; the shape differs between agents); the normalised form is in messages
result	string	the call's result, where one was recorded
ok	bool	true or false as recorded; null when the recording kept no status (the call can still have a result)
duration_ms	number	call duration in milliseconds
ts	string	step time, ISO 8601, as recorded; not always increasing within a session

2. messages

Column	Type	Description
trajectory_id	string	PK, FK -> trajectories
messages	list[object]	role (user, assistant, tool), content, is_wrapper (user), reasoning_content (assistant: the reasoning recorded before the turn), tool_calls (id, type, function: name, arguments as a JSON string), tool_call_id
tools	string	JSON list of the schemas of the tools the session called
ft_issues	list[string]	what makes the row harder to train on: starts_without_user, ends_without_answer, incomplete_tool_args, unnormalized_tool_args, withheld_text
models, n_steps, task_type, session_kind, is_eval … git_commit_made		as in trajectories
actor_id, repo_id, repo	string	pseudonyms

ft_issues values: starts_without_user, the first message is not the user's; ends_without_answer, the last message is not an assistant reply with text (it is a tool result, a user message, a tool call, or a turn that holds only reasoning); incomplete_tool_args, a call recorded no usable arguments (none, only a summary of them, or an edit or write call that recorded only its file path); unnormalized_tool_args, a call of a known tool kept its recorded arguments because no rule maps them safely (calls of MCP and unknown tools keep theirs without this flag); withheld_text, the row holds <WITHHELD>. A function name names the schema a call was mapped to: usually its normalised tool, or a more specific name where one tool has several argument shapes (for example exec and bash_input for shell calls, apply_patch and multi_edit for edits, task_create and task_update for task lists); tools holds the schema of each name, and sft_steps.tool keeps the normalised tool. For MCP and unknown tools the name is the recorded one with every character a function name does not allow replaced by _ (at most 64 characters), so a placeholder in it has no angle brackets (MODEL_B).

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; a tool step's text is its tool name)
tool, tool_raw	string	normalised and raw tool name (as in trajectories)
args	string	the call's arguments, as in trajectories
result	string	the call's result, cut to about 4,000 characters (the full result is in trajectories)
ok	bool	as in trajectories
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, as in trajectories
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
recovery_kind	string	the first later step that succeeded: same_tool_new_args, same_call_retried, other_tool, or none
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
is_eval … git_commit_made		the per-session facts, 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, 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 assistant message) 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. In v3, tool names the earlier mapping left as other were mapped to their tool, and vendor names left in raw tool names were masked as in the rest of the text (vendor_a, vendor_b and so on). The training form of messages maps the arguments of each known tool onto that tool's schema by the recorded parameter names. It drops some agent-specific options and adds no value that was not recorded; values stay as recorded, except that a URL-encoded path is decoded, a recorded line range becomes offset and limit, a timeout in seconds becomes milliseconds and a command recorded as a list of words becomes one string. trajectories, sft_steps and error_recovery keep every call's arguments exactly as the agent recorded them. tool takes 17 values in the full dataset; a tool outside them is other, and its own name is in tool_raw.

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 and so on. 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. 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 GATC-S 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. It found three secrets that the redactor and the gate had missed, in two of the 4,317 sessions: a signing secret that a setup tool printed, and a framework secret key and a database password, both set in a script. They are now <KEYBODY_n>; in these 100 sessions it found nothing to mask.

Release Gate

A handle (a user or account name) left in the text identifies its owner more easily in a small subset, where fewer owners share it, than in the whole corpus. GATC-S and this repository therefore each got one more masking round of their own, which replaced such handles, and a few account ids, 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. One effect: other (tools outside the normalised vocabulary) is 14.5% of this sample's calls and 2.4% of GATC-S's.

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, commits or code attribution: nothing marks whether a session's task succeeded or attaches the commits it produced. last_test_result and git_commit_made record what a test runner and git printed.
• session_kind marks only clear cases: 672 of the 4,317 sessions are marked interactive and 508 are unknown (in this repository, 18 and 29 of the 100); many of the unknown ones are interactive.
• is_eval flags 2,506 sessions of prepared evaluation tasks; it is not exhaustive, 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: 92.9% of the first prompts; prompt_language gives the language of each.
• In messages, calls of protocol (MCP) and unknown tools, and calls of known tools whose recorded shape no rule maps safely, keep their recorded arguments (see ft_issues under Dataset Schema); calls an agent issued in parallel appear one after another, as the recordings do not keep the grouping.
• Step times (ts) are as recorded: in 29.1% of the sessions a step's time is earlier than the previous step's.

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.)
• 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. schema_version stays gatc-v0.5; v2 files are the ones with session_kind. The final secret audit and a wider pass over the names of owners' own projects found nothing more to mask in these 100 sessions.
• v3 (13 Oct 2026): per-session facts added (is_eval, eval_kind, template_group, template_group_size, parent_trajectory_id, prompt_language, last_test_result, git_commit_made), user steps carry is_wrapper, error_recovery carries recovery_kind; messages rebuilt for training (an assistant turn holds its text, reasoning and tool call; arguments mapped onto per-tool schemas; tools and ft_issues added; v2 kept text and each tool call in separate messages); tool names re-mapped, with their step type, and task_type and key_tools follow the re-mapped tools (10 sessions of GATC-S changed task type, 1 of this repository); vendor names in raw tool names masked. schema_version stays gatc-v0.5; v3 files are the ones with is_eval. If you downloaded v1 or v2, replace it with v3: earlier files hold names in raw tool names that v3 masks.

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}
}