zetomatoz/guidellm-agentic-coding-trajectories

GuideLLM agentic coding trajectories

A sampled serving-load benchmark derived from Thoughtworks agentic-coding-trajectories, for GuideLLM and an OpenAI-compatible /v1/chat/completions endpoint. There are 630 rows representing 481 unique source sessions, across the same 8turn, 24turn, and 48turn configurations as the earlier version.

The configuration names now refer to original logical steps, not always HTTP request counts. Native tool steps expand into a tool-call request and a text-continuation request using GuideLLM's mocked client-tool workflow. Text-only rows keep one request per step. The Parquet files are ready to use with GuideLLM's default column mapper.

Compatibility was checked against GuideLLM commit a938aaa. Use a build supporting conversation_turns and client tool-call expansion; compatibility with older releases, including the earlier card's 0.7.3 recommendation, is not asserted. See the tool-calling guide and multi-turn guide.

Why this exists

Most LLM serving benchmarks use single-shot prompts. Coding agents work through multi-turn conversations, with each request carrying the preceding exchanges. This small sampled dataset has 630 rows: 90 eight-step, 450 twenty-four-step, and 90 forty-eight-step conversations. It provides varied prompts and growing context for a quick stress test of a Ray-backed inference system without converting all 15,000 source records or provisioning their development environments. GuideLLM's concurrent profile runs multiple conversation sequences in parallel; --profile kind=concurrent,streams=500 can target 500 concurrent simulated chat streams. HTTP streaming is enabled separately by stream=true in the backend settings. Together they let you observe latency, throughput, and context growth under concurrent load. These are simulated chats; sampled source sessions can be reused across configurations or runs.

This is a load profile. Model answers, selected tool arguments, and the mocked results need not form a correct solution to the original programming task. GuideLLM generates fresh assistant responses and never executes the original tools.

Fixed text output, complete tool calls

All existing output_tokens_count_i values are retained exactly, using the original Qwen/Qwen3.8-27B token targets. For ordinary text requests, GuideLLM sets max_completion_tokens=N and ignore_eos=true. For a native tool step, GuideLLM removes these controls from the tool-call request and transfers the existing token target to the text continuation after the mocked result. The server can finish the tool-call JSON; the following text reply still carries the original fixed decode budget.

Therefore the fixed text-token budget is unchanged, and variable-length tool-call generation is added. About 74% of requests in a complete pass have fixed text-output targets. Actual token usage still depends on server behavior, errors, context limits, and model/tokenizer alignment. Compare serving configurations using the same revised dataset; its request mix and context differ from the old flattened version.

Configuration	Rows	Native-tool rows	Requests per text-only / native-tool row	Requests in one full pass	Fixed text-output token budget
8turn	90	30	8 / 16	960	98,710
24turn	450	155	24 / 48	14,520	1,889,433
48turn	90	35	48 / 96	6,000	908,668

Only the OpenHands portion of the sample has structured native tool calls. The mini-swe-agent and SWE-agent portions submit shell commands as text; those rows retain their earlier prompts and text-output targets.

What is mocked

The recovered originals contain tool-call names, arguments, IDs, and result strings, but no tool-definition schema. Native tools are replaced with GuideLLM's built-in placeholder function, get_data(query: string), with tool_choice=required. The original native call locations determine which steps use tools. Tool correctness is outside this benchmark's purpose.

Each mock result uses the recorded output associated with that original step. If the original step had several calls, their results are joined into one string. At runtime, GuideLLM binds the recorded result to the fresh model-generated call ID. If a live response contains additional calls, GuideLLM supplies its default placeholder result for those extra calls. Original assistant outputs are not injected as new model responses.

For example, the pydicom session chatcmpl-a90b0a274259775b81dac86e716dd535 is row 1 in the 8turn file. Its first three original tools are think, str_replace_editor, and execute_bash. The old output targets for those steps are 456, 427, and 84 tokens.

For the execute_bash step, the revised workload is:

Stage	What happens	Output-length control
Tool-call request	The model produces a fresh get_data call	GuideLLM removes the dataset token cap and forced-EOS controls
Mock injection	GuideLLM sends the recorded shell-result text as a role: tool message, using the fresh call ID	The result is input text; no shell runs
Text continuation	The model replies to that result	The original 84-token target is enforced by the usual GuideLLM controls

The eight-step pydicom row becomes 16 requests while preserving its full 1,458-token fixed text-output budget, plus the generated tool calls. Later native steps use a short continuation prompt; recorded results already enter history through the injection, so they are not repeated in the next user prompt.

Schema

Each row contains source metadata, numeric workload metadata, and a conversation_turns JSON string. This string packs a simple linear graph whose parent links carry full conversation history. Numeric metadata such as logical_steps does not match GuideLLM's default text-column names.

Inside each logical step, the mapped columns are:

Column inside conversation_turns	Content
text_column	A one-element list containing the prompt
prefix_column	The original system prompt, on the first step only
output_tokens_count_column	A one-element list containing the original fixed token target
tools_column	On native steps only: a one-element list containing JSON for the mock function definition
tool_choice_column	On native steps only: ["required"]
tool_response_column	On native steps only: a one-element list containing the recorded mock-result string

The default finalizer expands native steps into client_tool_call and tool_response_injection nodes, moving output_tokens_count_column onto the injection node. No column-mapper overrides, message extractor, or GuideLLM source edits are required for this packed format.

First smoke run

Download and unzip the revised files, and replace RAY_HOST and SERVED_MODEL_NAME. Use a Ray/vLLM deployment configured for native tool calling and constrained decoding with the parser appropriate to the served model.

guidellm run \
  --backend 'kind=openai_http,target=http://RAY_HOST:8000,model=SERVED_MODEL_NAME,request_format=/v1/chat/completions,stream=true' \
  --tokenizer 'kind=huggingface_auto,model=Qwen/Qwen3.8-27B' \
  --data 'kind=parquet_file,path=/path/to/train-8turn.parquet' \
  --data-loader 'kind=pytorch,samples=2,shuffle=false,num_workers=0' \
  --data-finalizer 'kind=generative,tool_call_mode=client' \
  --profile 'kind=concurrent,streams=1' \
  --constraint 'kind=max_requests,count=24' \
  --constraint 'kind=max_duration,seconds=300' \
  --output 'kind=json,path=guidellm-tool-smoke.json'

The first two rows include one text-only row and the pydicom native-tool row: 8 + 16 = 24 requests when both complete successfully. Check errors and actual output tokens before increasing concurrency. Do not set global extras.body.ignore_eos=false, extras.body.max_tokens, or extras.body.max_completion_tokens; the dataset and GuideLLM should control ordinary text budgets and native tool-call exceptions separately. Server-side defaults still apply to uncapped tool-call requests.

Concurrent load run

After uploading this revision to Hugging Face, use:

guidellm run \
  --backend 'kind=openai_http,target=http://RAY_HOST:8000,model=SERVED_MODEL_NAME,request_format=/v1/chat/completions,stream=true' \
  --tokenizer 'kind=huggingface_auto,model=Qwen/Qwen3.8-27B' \
  --data '{"kind":"huggingface","source":"zetomatoz/guidellm-agentic-coding-trajectories","load_kwargs":{"name":"24turn","split":"train"}}' \
  --data-finalizer 'kind=generative,tool_call_mode=client' \
  --profile 'kind=concurrent,streams=16' \
  --constraint 'kind=max_duration,seconds=900' \
  --output 'kind=json,path=guidellm-24turn-16streams.json'

Use the same configuration at increasing stream counts, including streams=500 when that is the intended load target. In an offline environment, replace the Hugging Face data setting with kind=parquet_file,path=/path/to/train-24turn.parquet.

Context estimates now include the added tool-call/injection pairs. Maximum estimated input-plus-output context is approximately 22,337 tokens for 8turn, 53,586 for 24turn, and 67,214 for 48turn. These estimates use Qwen content tokenization, 12 tokens of overhead per message, and an assumed 256 generated tokens per tool call; 256 is an estimation assumption, not a runtime cap. Uncapped tool calls and actual chat templates can change context usage. The revised 48turn tool rows exceed the old 56,000-token budget, so use a sufficiently large server context or start with 8turn and 24turn.

Build and validation

The original sample comes from Thoughtworks sessions.parquet at revision cef72d1f4d0caabf85937adf8337a14b7522c782. The input contained 1,947 repeated session_id rows; the original converter retained the first record for each ID and selected a seeded sample. This revision reuses exactly the existing 630 rows and recovers only their 481 unique original sessions. The rest of the 15,000-row corpus was not parsed for this rebuild.

Every recovered source prompt was matched against the existing sample before conversion. Offline checks using the reviewed GuideLLM modules passed for all 630 rows and 21,480 expanded requests: default column mapping, graph finalization, fixed token-target preservation, tool-specific request controls, fresh call-ID/result pairing, and streaming tool-call fragment assembly. See validation.json and workload-summary.json.

This revision has not been tested against the user's Ray endpoint. The offline checks establish formatting and budget preservation; a live smoke run is still needed to verify server tool support and whether the reported 400 errors are resolved.

Source terms and attribution

This is an adapted, sampled benchmark derived from Thoughtworks/agentic-coding-trajectories (revision cef72d1f4d0caabf85937adf8337a14b7522c782), itself a derivative of three upstream trajectory datasets. Changes here: sample and deduplicate sessions, count output targets with a Qwen tokenizer, and select the original sample using an estimated context budget. This revision recovers native tool-call metadata and recorded results for the sampled sessions, packs conversations into GuideLLM graphs, substitutes one mock function for native tools, and moves the existing fixed output targets to text continuations. Text-command sources retain their original flattened prompts. Context estimates are recalculated for the expanded workload. These files include original trajectory text. Credit Thoughtworks and the upstream dataset creators when reusing or sharing them.

license: other and license_name: derivative-multi-source describe the mixed provenance; they do not grant a single new license for all rows. See LICENSE for source links and terms. Every row includes source_dataset and source_id so its upstream source can be identified. The 8, 24, and 48 turn configurations contain 90, 450, and 90 rows respectively; source records can occur in more than one configuration.

source_dataset	Upstream trajectories	Published dataset license	Rows in 8 / 24 / 48 turn configs
nebius-swe-rebench-openhands	Nebius SWE-rebench OpenHands trajectories	CC BY 4.0; underlying repository content may have additional terms	30 / 155 / 35
swe-smith-claude-3-7-sonnet	SWE-bench SWE-smith trajectories	MIT on dataset card; Claude-generated content is also flagged by Thoughtworks as subject to Anthropic's Usage Policy	30 / 154 / 35
kwai-klear-swe-smith-mini	Kwai-Klear mini-swe-agent-plus trajectories	MIT on dataset card	30 / 141 / 20

The upstream dataset cards and their terms are the authority for each source. Repository licensing of code appearing within trajectories may be distinct from dataset licensing. This dataset card does not certify that publication or commercial use is permitted for every included record. For citation, see the Thoughtworks card and the three linked upstream cards.