Introducing Voyages: Automatic Agent Telemetry

Long-horizon agents fail silently. Sail Voyages is the system of record for agentic workflows: an agent telemetry SDK with first-class support for Sail inference and Sailboxes that turns every run into a fully attributed, versioned, human-legible trace. And with our new Claude Code and Codex skills package, your coding agent can one-shot a background agent on Sail from a single prompt.

Model capability continues to accelerate. Agents apply this intelligence so effectively that the worry is no longer whether they can do useful work. It is that they can: for increasingly long stretches and in increasingly many places, with fewer and fewer human touchpoints.

A model can decide which sources to read, write scripts, run tests, retry failures, produce a report, and leave you with no clear record of what actually happened. For agents to move from impressive to trusted, businesses need the same thing they expect from any critical workflow: a system of record. Which agent made which model call? Which command ran in the sandbox? What changed between versions of the harness? Where did the run slow down, and where did it fail?

Sail Voyages is that layer.

Introducing Voyages

A Voyage is one run of an agentic workflow. The SDK records the agents, spans, events, model calls, sandbox commands, errors, and artifacts that make up the run, keeps a durable log across versions of your harness, and renders the trace into something human-legible.

import sail

@sail.agent("Researcher")
@sail.span("collect sources")
def collect_sources(sailbox, urls):
    return sailbox.exec(fetch_sources, urls)        # attributed automatically

@sail.agent("Analyst")
def score_evidence(sources):
    # No @sail.span needed. Sail creates an auto-span.
    return sail.inference.responses.create(...)     # attributed automatically

with sail.voyage.run(
    name="deep-research",
    version=2,
    sailbox_id=sailbox.sailbox_id,
):
    sources = collect_sources(sailbox, urls)
    result = score_evidence(sources)

Voyages is designed around two key principles: simplicity and flexibility. It is unopinionated by design. It works with any harness, any agent loop, and any SDK. You bring the architecture that makes sense for your task. Voyages gives you the lightweight decorators for labeling agent and span work.

Start a voyage run, put @sail.agent and @sail.span on the functions or phases you care about, and Sail attributes the model calls and Sailbox commands underneath. No passing headers around. No extra lift required.

The dashboard answers the questions that actually matter when an agent misbehaves: which agent made which tool call, what came back, how long it took, and where the failure originated.

The Sail platform

Sail is built for long-horizon background agents. We believe an agent's work belongs in a sandbox: a durable VM to write code and run tests in, a filesystem to manage context and save artifacts, and isolation that lets developers sleep while their agents work. Sail already operates the layers where agent work happens.

1. Inference is the intelligence tap an agentic system reasons with, built for long, token-heavy, unattended trajectories.
2. Sailboxes are the safe, durable execution layer: multi-day workflows, arbitrary code execution, and the tools raw models need to power production work.
3. Voyages is the visibility layer: a thin SDK that brings the human back into the loop with clear insight into what their agents did, and why.

These synergies are precisely why Voyages is more powerful than bolting tracing onto the agent harness after the fact. Most tracing tools only see what your app manually reports. Sail sees the work directly: the model call through Sail inference, the command inside the Sailbox, and the agent/span context from Voyages. One trace. No collectors, no correlation headers, and no logs to reconcile after the fact.

Sail already operates the layers where agent work happens.

This featherlight integration pattern matters most when agent harnesses change. Prompts get optimized, models swapped, subagents added to the loop: the developer does not need to keep track of which changes improved outcomes and which caused silent regressions. Voyages tags each workflow with a series name and version. Bump the version as the harness changes and the dashboard tracks success rates, median duration, error patterns, and run history.

This is how you hill climb on agentic systems with ease.

Have your agents build with Sail

We are publishing sailresearchco/sail-skills, an Agent Skills package that teaches coding agents the Sail pattern: start a Voyage, declare meaningful agents and spans, run work in a Sailbox, call Sail inference, retrieve artifacts, and complete or fail the run cleanly.

We tested whether a coding agent could use that pattern from a raw prompt. We installed the plugin in Claude Code and in Codex, pointed each at an empty directory, and gave them the same three-sentence prompt:

I want to build a small background research agent on Sail and actually be able to see everything it does. The task: figure out which of three sports - tennis, basketball, or running - is healthiest for you long-term. Compare them across the major health dimensions using reputable sources, then produce a ranked result with a short write-up and a simple chart.

Both built a working multi-agent system on the first attempt. Sources fetched inside a Sailbox. Scoring and synthesis through Sail inference. A report and chart written from the sandbox and saved to disk. Most importantly, every meaningful step showed up in the Voyages dashboard, attributed to the agent that did it.

This is the product experience we want to support at Sail: serious tools for businesses building serious agents. Voyages is flexible and unopinionated: minimal lift to add, maximal visibility in return. And the skills package means frontier coding agents can write the glue themselves, which makes the migration feel less like an SDK integration and more like asking your agent to become observable.

We believe agents will build more and more of their own harnesses. Our telemetry layer reflects this future. It is easy for agents to pick up, simple for a human to trust, and closest to where the work happens.

Try it today

Voyages is in beta and included free with every Sail account.

Claude Code

/plugin marketplace add sailresearchco/sail-skills
/plugin install sail@sail

Codex

codex plugin marketplace add sailresearchco/sail-skills
codex plugin add sail@sail

Install the SDK, create an API key at app.sailresearch.com/api-keys, and set it in the environment where your agent runs:

pip install "sail-sdk>=0.2.1"
export SAIL_API_KEY=sk_...

Give your agents a hard problem and try us out.