kosiasuzu/agenticml-agent-trajectory-dataset

Telos Agent Trajectory Dataset

Synthetic multi-turn agent trajectories for training LLMs to emit structured tool-use loops. Each trajectory is provided in two parallel representations: the Telos frame format and an equivalent ChatML+tools rendering of the same behavior.

This is synthetic data distilled from Qwen3.5 Plus (2026-04-20) via OpenRouter. Users who require data not derived from a specific provider should factor this into licensing and downstream-use decisions before adopting.

What is Telos?

Telos is an agent serialization format that treats each step of an LLM agent loop as a typed frame rather than a chat message. Where ChatML+tools encodes agent behavior as messages with tool_calls, Telos uses distinct frame types — goal, mission, obs, belief, plan, think, action, result, feedback, reward — each opened by a reserved special token. The format aims to make agent loops first-class at the serialization layer rather than emergent from chat conventions.

The two parallel representations enable matched-format comparison studies: training the same base model on frames (Telos) vs messages (ChatML+tools) on identical underlying behavior isolates the format-effect contribution to any downstream evaluation.

Record schema

Column	Type	Description
id	string	Stable example id, domain-prefixed (e.g. res_attn_005)
domain	string	One of 23 domain labels (see below)
frames	string	JSON-encoded list of Telos frame objects (type + content)
messages	string	JSON-encoded ChatML+tools rendering of the same trajectory
num_frames	int64	Number of frames in the parsed frames list

frames and messages are stored as JSON strings so Arrow can hold heterogeneous nested payloads cleanly. Consumers must json.loads() them on read.

Usage

import json
from datasets import load_dataset

ds = load_dataset("kosiasuzu/telos-agent-trajectory-dataset")
row = ds["train"][0]

frames = json.loads(row["frames"])      # Telos representation
messages = json.loads(row["messages"])  # ChatML+tools representation

For training a Telos-format model, tokenize frames rendered through the Telos SDK (telos.frames.render). For training a ChatML+tools baseline, pass messages directly to tokenizer.apply_chat_template(messages, tools=...).

Telos wire format

A Telos trajectory is a sequence of frames separated by reserved special-token markers. There are no closing tokens; each frame extends from its opening marker until the next marker or end-of-string.

Marker	Owner	Payload	Purpose
<|goal|>	runtime	prose	Persistent role / system instruction
<|mission|>	runtime	prose	The specific task to solve
<|obs|>	runtime	prose	Runtime context (tool defs, env state)
<|belief|>	model	prose	Updated understanding after a result
<|plan|>	model	prose	Strategy when path is non-obvious
<|think|>	model	prose	Private reasoning (stripped after consumption)
<|action|>	model	JSON	Tool call: {"tool": "...", ...args}
<|result|>	runtime	JSON	Tool outcome: {"ok": 0|1, "value": ...}
<|feedback|>	runtime	prose	Follow-up turn from the user
<|reward|>	runtime	number	Training-time signal (RL, deferred for v1)
<|end|>	model	—	Block-boundary / generation stop token

<\|end\|> is not a frame. It is a wire-level token only: emitted by the model to close a generation block, consumed by the parser as a separator. It does not appear in the frames representation. Renderers insert it automatically at model→runtime boundaries.

Terminal actions (tool: "answer" or tool: "fail") end the trajectory. They are not followed by a result frame.

Token mapping (Llama-3.1)

The 11 reserved markers map to <|reserved_special_token_N|> slots in the Llama-3.1 tokenizer:

Marker	Reserved slot	Token ID
<|goal|>	0	128002
<|mission|>	1	128003
<|obs|>	2	128005
<|belief|>	3	128011
<|plan|>	4	128012
<|think|>	5	128013
<|action|>	6	128014
<|end|>	7	128015
<|result|>	8	128016
<|feedback|>	9	128017
<|reward|>	10	128018

Models other than Llama-3.1 have different reserved-token layouts and require remapping. The dataset itself is tokenizer-agnostic at the string level.

How the data was generated

Trajectories were generated by Qwen3.5 Plus (2026-04-20) via OpenRouter, prompted with the Telos format specification, structural rules, and three exemplar trajectories. The prompt explicitly forbids common failure modes observed in earlier attempts (placeholder result values, recycled belief phrases, belief/plan loops, tool-result mismatches).

Generation was seeded by 50 hand-authored trajectories spanning the target domain distribution. Seeds are included in the training split.

Domain distribution

Trajectories cover 23 domains, generated with a target distribution but classified by a keyword fallback for any trajectory missing an explicit domain field. Top domains by share approximately match the prompt's target table:

• coding (12%)
• finance (8%)
• writing (8%)
• research (8%)
• scheduling, cooking, travel (6% each)
• tutoring, smart_home, shopping, media, news, health (4% each)
• photo, interpersonal, legal, civic (3% each)
• vehicle, support (2% each)

Additional minor domains (home, unknown, and a handful of edge classifications) account for the remaining mass and total to 23 distinct labels.

Source pipeline

Produced with scripts/data_scripts/clean_and_push_telos_data.py from data/generated.jsonl:

1. Require id, frames, domain per line; empty domain normalized to unknown.
2. Validate each trajectory through the Telos parser, renderer, and sequence validator.
3. Deduplicate by normalized mission text (lowercase, whitespace-collapsed, SHA-1 hash).
4. Stratified train/eval split by domain (eval_frac=0.05, RNG seed 42).
5. Convert each trajectory to a parallel ChatML+tools representation for the messages column.

Snapshot statistics:

• Raw JSONL: 19,892 lines (81.8 MB)
• After validation: 19,686 rows (~1% rejected)
• After dedup: 19,465 rows
• Final split: 18,491 train / 974 eval (95% / 5%)

ChatML+tools conversion

The messages column is generated programmatically from the frames column. The mapping:

• goal and obs → concatenated into a system message
• mission → user message
• belief, plan, think → inlined into the content of the next assistant message (so the baseline model sees the same reasoning)
• action (non-terminal) → assistant message with tool_calls
• result → tool message
• action (terminal: answer or fail) → final assistant message; preceding reasoning is folded into its content
• feedback → subsequent user message
• reward → dropped (no ChatML equivalent)

Tool call IDs are assigned sequentially per trajectory.

Limitations

• Synthetic data, factual content not verified. Trajectories in research, news, legal, and vehicle-diagnostic domains may contain fabricated specifics (paper titles, statistics, routing numbers, repair costs). The data teaches format and behavior, not facts.
• Single user turn. Each trajectory has exactly one mission and at most one feedback follow-up. Extended multi-turn dialog is out of scope for v1.
• Illustrative tool schemas. Tool definitions are TypeScript-style namespace declarations chosen to match each task. They are not drawn from any real tool registry.
• English only.
• Teacher-model artifacts. Reasoning patterns and belief framings reflect Qwen3.5 Plus's generation style; trained models will inherit some of this.
• Domain classifier fallback. A small fraction of trajectories were tagged via keyword inference rather than the teacher's explicit label, which may introduce mislabeled rows.

License

MIT.

Citation

@dataset{telos_trajectories_v1,
  title  = {Telos Agent Trajectory Dataset},
  author = {Asuzu, Kosi},
  year   = {2026},
  url    = {https://huggingface.co/datasets/kosiasuzu/telos-agent-trajectory-dataset},
  note   = {Synthetic agent trajectories in Telos frame format with parallel ChatML+tools rendering. Generated with Qwen3.5 Plus (2026-04-20) via OpenRouter.}
}

If you use this dataset to train or evaluate a model, please also cite the Telos project repository for the format specification and SDK.