Skip to main content
Seven of the eleven tools answer “what is there” and never return a captured value. Pick a trace or a function here, open it with shape, fetch bytes with values. Every response below was captured against a server seeded with the spec’s conformance trace on team fixture: 17 steps, root_status: error, one three-attempt step, environment prod. The token’s team-set is demo and fixture. Each bound below is the one that tool’s schema carries, which install separates into server-reported and fixed.

​
Shared arguments

Five of the seven tools on this page take team and environment: vexlo_check_trace_status and vexlo_find_related_traces scope themselves through the ids they are handed. vexlo_get_function and vexlo_get_function_examples take the same two, so this section defines them for the whole site. team is an array of team ids; omit it for every team the token can see. An id outside the token’s team-set is dropped, and the response says which:
When every requested id is outside the set, no request is sent and the tool returns its own route-shaped empty result, so a scope limit never reads as a real empty answer:
No live session carries a service pin, since a service-pinned read token never finishes startup. So a misspelled service name and a real, empty one look identical until vexlo_check_coverage answers. On every paginated tool the last page carries next_cursor: null rather than omitting it.

​
vexlo_search_traces

Returns root status, completeness, step and error counts, tags, and duration per trace. Never step-level detail, never captured values. Narrow before widening limit: at the ceiling of 100, one page costs more tokens than a whole trace’s shape. The default of 10 is below the API’s own 50, which the ladder measures at 7,127 tokens for the search alone.
matched_tag_keys appears on a row only when tagValue was set and tagKey was not: naming the key suppresses the field. A running row omits root_function, root_status, and duration_ms rather than emptying them, withholding all three until the root attempt lands.

​
vexlo_check_trace_status

Takes traceIds, 1 to 100, and nothing else: no other filter applies here. The tool sends ?limit=<count of ids>, so limit reads 2 below. Rows are the shape search returns:
not_returned is the tool’s own field: the ids asked for minus the ids returned, omitted when every id came back. An id lands there because no such trace exists or because it belongs to a team this token cannot see, two cases the API keeps indistinguishable. next_cursor is always null, since every id named resolves on one page. The only way to see what else touched one request once this trace’s steps end at its service’s edge. It reports that traces share a tag, never that one called the other; call relationships live on vexlo_get_function. No team or environment: the search is scoped to the anchor trace’s own team. The 168-hour ceiling is the route’s own 7-day cap, which keeps the server’s silent clamp out of reach. An empty result is ambiguous by construction: nothing else ran, nothing else carries that tag value, or another trace spells the value under a key this one does not use. Service plays no part: two traces from one service relate through a shared tag like any others. The window is anchored to wall-clock now, never to the anchor’s started_at, so a trace older than seven days is unreachable whatever windowHours says. On an empty result the tool spends one point read on the anchor to check whether that is the reason:
note is omitted when items is non-empty, and when the anchor falls inside the window. An item carries trace_id, service, shared_tags, started_at, and root_status, that last absent while its own root runs.

​
vexlo_list_functions

One row per function, ranked by observed_count descending, each row that function’s aggregate across every caller. Names and counts only: no caller or callee edges, no examples.
is_entry_point says the function has been observed opening a trace. A row carries team only when the read resolved to one team; where it is absent the row sums every team in scope, so pass one team id to attribute observed_count and error_count.

​
vexlo_list_tags

Arguments: team, environment (named values only), service (single name), and limit and cursor with the same computed bounds as vexlo_list_functions. A tag only one service emits has not been seen crossing a service boundary in this team’s traces.

​
vexlo_check_coverage

The one place to learn which service and environment names exist for a team; there is no list-services route. Arguments: team, environment, service. No limit or cursor: the route is never paginated.
A row carries environment when the query filtered by one. marked_functions_seen counts only marked functions: a low number means little of the service is marked, never that the service does little.

​
vexlo_check_health

Disk and value-store budget, retention, and per-service record loss, from the same three arguments vexlo_check_coverage takes.
Under disk pressure the server answers status: "degraded" and mode: "shape_only" with HTTP 503, which this tool returns as data, not a failure (errors, rate limits, retries explains how). In that mode a value handle elsewhere reads as unavailable for newly captured data, not as nothing captured. The team-level stubs_swept_24h field the route sends is absent from this result.

​
What each response above cost

Measured over the one-line text each tool returned; the blocks above are jq . renderings of it. Token costs has the full ladder, including these tools’ widest pages.