weaviate/QueryAgentGym

Query Agent Gym

Query Agent Gym is a set of procedurally generated database environments and natural-language queries with exactly known ground-truth queries.

This release holds five held-out test environments containing 15 collections with 1,000 objects each (15,000 objects, 18,000 searchable documents) and 250 queries, 50 per environment. Every entity, name, and document is synthetic.

Environment	Collections (kind)	Objects	Queries
Public Transit	TransitRoutes (knowledge_base), RidershipReports (transactional)	2,000	50
Tattoo Studios	TattooArtists, TattooDesigns (knowledge_base)	2,000	50
Nonprofits	Charities, Campaigns, GivingPrograms (knowledge_base), Donations (transactional)	4,000	50
Surf Schools	SurfBeaches, SurfInstructors, LessonPrograms, SurfEquipment (knowledge_base)	4,000	50
Childcare	DaycareCenters, ChildcareStaff (knowledge_base), ChildEnrollments (transactional)	3,000	50

Quick start

from datasets import load_dataset
import json

queries = load_dataset("weaviate/QueryAgentGym", "queries", split="test")
surf = queries.filter(lambda r: r["environment"] == "surf-schools")
q = queries[0]
print(q["command"])                     # the natural-language request
print(q["ground_truth_sql"])            # readable ground truth, one entry per sub-query
plan = json.loads(q["ground_truth"])    # exact ground truth (query_database arguments)

routes = load_dataset("weaviate/QueryAgentGym", "public-transit_TransitRoutes", split="test")

Layout

Each environment has its own folder.

environments.parquet                   one row per environment
<environment>/schema.json              the schema exactly as generated
<environment>/queries.parquet          the environment's 50 queries
<environment>/objects/<Collection>.parquet   1,000 objects per collection

Config	Rows	Contents
queries (default)	250	All five environments' queries, with an environment column
environments	5	One row per environment
<environment>_<Collection>	1,000 each	The objects of one collection, one typed column per property

To work with one environment, filter the queries config on environment, or read <environment>/queries.parquet directly.

queries

Field	Type	Description
query_id	string	e.g. public-transit-013
environment	string	Environment id, e.g. public-transit
environment_name	string	e.g. Public Transit
command	string	The natural-language request given to the agent
phrasing	string	explicit (names properties and values plainly) or conversational (a scenario, with values still verbatim)
plan	string	The operators of the plan, sub-queries separated by ;
num_sub_queries	int	1 to 3. Sub-queries are independent, never multi-hop
operator_classes	list of strings	Operator classes the plan features (search, each filter kind, each aggregation kind, group-by, multi-query)
ground_truth	string (JSON)	List of query_database argument objects, one per sub-query (format below)
ground_truth_sql	list of strings	A SQL-like rendering of each sub-query, for reading only
search_grounds	list of structs	For each sub-query with a search, its relevance-labeled result set (below)
reference_results	string (JSON)	Each sub-query's ground truth executed on the objects (below)

Objects

Each <environment>_<Collection> config has a uuid column followed by one column per property, in schema order. The uuid is the object's id and is what search_grounds and reference_results refer to. Property types map to columns and to Weaviate data types as follows.

Property type	Column type	Weaviate data type
searchable_text	string	text (the prose a search should match)
filterable_text	string	text (identifiers, references, categories)
int / number	int64 / float64	int / number
boolean	bool	boolean
date	string, YYYY-MM-DD	date (send as RFC 3339, e.g. 2025-11-16T00:00:00Z)
text_array, int_array, number_array, boolean_array, date_array	list	text[], int[], number[], boolean[], date[]

Each collection has exactly one identifier property (is_identifier in schema.json): an invented, unique name in a knowledge_base collection, a code in a transactional one. A transactional collection's reference properties (references in schema.json) hold the identifier of a knowledge_base record, stored directly in the row, so no query needs a join. No value is null.

Ground truth format

A ground truth is a list of sub-queries, each a query_database function-call argument object.

[{"collection_name": "TransitRoutes",
  "search_query": "observatory and weather access",
  "numeric_array_property_filters": [
    {"property_name": "stopSequenceNumbers", "operator": "CONTAINS_ALL", "values": [1, 8]}]}]

Argument	Items	Operators or metrics
collection_name		The target collection
search_query	string	A relevance search over the collection's searchable text
text_property_filters	property_name, operator, value	=, LIKE (pattern uses %, e.g. Nerith%)
numeric_property_filters	property_name, operator, value	=, <, >, <=, >=
date_property_filters	property_name, operator, value (ISO date)	=, <, >, <=, >=
boolean_property_filters	property_name, operator, value	=, !=
array_property_filters (text arrays), numeric_array_property_filters, boolean_array_property_filters, date_array_property_filters	property_name, operator, values	CONTAINS_ANY, CONTAINS_ALL
numeric_property_aggregations	property_name, metric	COUNT, MIN, MAX, MEAN, MEDIAN, MODE, SUM
text_property_aggregations	property_name, metric, top_occurrences_limit	COUNT, COUNT_DISTINCT, TOP_OCCURRENCES
boolean_property_aggregations	property_name, metric	COUNT, TOTAL_TRUE, TOTAL_FALSE, PERCENTAGE_TRUE, PERCENTAGE_FALSE
date_property_aggregations	property_name, metric	COUNT, EARLIEST, LATEST
groupby_property	string	Groups every aggregation of the sub-query

All filters in a sub-query are combined with AND. A sub-query without aggregations retrieves records, and one with aggregations returns only the statistics.

Searches. The words of search_query are one valid phrasing and are not the target. A search sub-query's correct result is its labeled set: search_grounds[i].candidate_ids are the records the sub-query's filters select (R), and relevant_ids are the records a language model labeled relevant to the topic after reading every document in R (S). The topic and description fields say what the search is about.

Reference results. reference_results[i] is sub-query i executed on the objects, with a search resolving to its relevant_ids. A retrieval is a sorted list of uuids, an aggregation is {"METRIC(property)": value}, and a group-by maps each group value (as a string) to its aggregations. Percentages are on a 0 to 100 scale, and TOP_OCCURRENCES is a list of [value, count] pairs. Ties in MODE and TOP_OCCURRENCES are broken deterministically, which a database may break differently.

Evaluation

Placeholder, see github.com/weaviate/query-agent-benchmarking.

How the data was made

Each environment is a position in a seeded order over 200 domain briefs (seed 380, positions 5 to 9). Its structure is sampled procedurally: the number and kind of collections, property types, references, and each query's operator plan. Language models write the surface: the schema design (GPT-6 Sol), record names and documents (GPT-6 Luna), search topics and their relevance labels, and the natural-language commands (GPT-5.6 Luna). Ground truths are grounded in the saved objects and every command passes mechanical checks and a faithfulness verifier, so the plan can be recovered from the words. Each set of 50 queries is selected from a pool of 200 sampled plans so that every operator class appears at least 3 times, which makes the sets balanced across operators rather than distributed like natural traffic. A seeded coin chose each command's phrasing, giving 113 explicit and 137 conversational commands.

Limitations

• All data is synthetic and English only. Entities are invented, so an agent cannot answer from world knowledge, and documents are written as a real system of record would write them.
• Values are drawn independently, so a record can combine values that would rarely co-occur in reality (a fin set tagged for zipper care). Documents are written to stay consistent with each record's values.
• Public Transit has no group-by queries. Its only groupable properties are references with over 400 distinct values, which yield degenerate groups.
• Relevance labels for searches come from a language model reading each candidate document, not from human annotation.