The Ticket Is Dead. Long Live the Trajectory.
Every quarter at Sainapse, a goal is born in a meeting. Something like: cut first-response time by 10×. Within a week it has passed through a planning doc, a long Claude chat where the spec got sharpened, and then it fans out — background coding sessions picking up issues, PRs opening while I sleep, eval runs, a support workflow rewired, a handful of my mid-course corrections.
Ask my tooling what all of that was, and it has no answer. GitHub knows the PRs. Linear knows the tickets. The chat knows the spec. Nothing knows they were one thing.
An agent trajectory is the ordered set of sessions, artifacts, and human steers that jointly achieved one goal — not one chat, not one PR, the whole path.
The important property is that trajectories nest. The roadmap decision is itself a trajectory — the meeting and the Claude chat are its first artifacts — and it is the root of every downstream coding session. Draw it and the shape is obvious:
Every box already exists in some tool. The tree exists nowhere.
I'll make an unfashionable claim: none of this is new. In reinforcement learning, a trajectory is literally the training unit — the path, not the outcome — and agent evals have followed, grading full traces of tool calls and recoveries because the right answer via a wrong path is a bug you haven't met yet. Organizations converged on the same container decades ago: the legal matter file, the incident postmortem, the after-action review. Even the economics is old — Coase said firms beat markets by lowering coordination costs, and a fleet of cold-starting agent sessions is a firm with no files, paying the coordination tax on every run. The trajectory just marries the two lineages: the machine world's trace, the org world's goal.
Tickets are one level of abstraction too low
The closest existing thing is the task tracker, which is exactly why the concept feels familiar. Jira, Linear, and GitHub Issues solved this problem for humans: make work legible so it can be assigned, tracked, and reviewed.
But a ticket is scoped to a task, and an epic — the tracker's gesture at goals — is prose stapled above the tickets, readable only by people. That was the right altitude when humans did the work, because the human carried the goal in their head between tickets.
Agents don't. A fresh session carries nothing. So the tracking layer has to hold what the human head used to: the goal, its success criteria, the sessions so far, the steers issued, the failures already hit. That's a trajectory — a machine-readable epic. And this is the premise of the whole paradigm:
You can't automate what you can't name. Trajectories are how a company finds out what its goals actually are.
Every steer I issue is a fragment of a goal definition I failed to write down. When I catalog my corrections — the follow-ups, the mid-session 180s — the recurring ones are an after-action review telling me which goal to formalize next. At Sainapse we've started treating that catalog as roadmap input: the processes we automated first were the ones whose steer patterns had become boringly predictable.
The steers are measurable, and the measurement surprised me. A merged PR from our background harnesses now costs a median of about two human review comments. Our interactive PRs — a human driving with AI assist — cost three to four. The corrections didn't disappear on the autonomous path; they moved upstream, into the goal definition, where they get paid once instead of per session.
Human review moves up — slanted by stakes
Once the trajectory is the unit, review stops meaning "read every artifact."
Above the plane, agents verify agents. Below it, a human still looks.
At Sainapse the plane is slanted by stakes, honestly. Internal ops — briefings, digests, monitoring, the pipelines that keep the company running — I read trajectory summaries and spot-check. Customer-facing production sits at the other end. At one enterprise deployment of our support agents — four hundred specialists, over a million tickets a year — the agents triage and draft essentially every inbound ticket, and essentially nothing ships without a specialist looking. That's the plane pinned at artifact level, by design. But 95% of those drafts ship with zero edits: review at that altitude has already become a glance. That is how the plane moves — it drifts as verification earns trust; it never jumps.
This is what "your observability has to scale accordingly" means. We built Neura, an internal tool, precisely because nothing off the shelf records this: goals, the sessions under them, the steers, the cost. Not because tracking is novel — because tracking at ticket altitude can't tell you whether a goal is converging.
Scale becomes a token dial — conditionally
Here is the boldest claim, stated exactly as true as it is. For processes where we've defined the trajectory — named the goal, written the success criteria, captured the steers — our throughput at Sainapse is now a function of how many tokens we're willing to spend.
Measured from our telemetry and GitHub org, trailing 90 days.
Those PRs land against scoped issues, from roughly 12,600 coding sessions behind them. The merge rate is statistically indistinguishable from our humans' — and the list-price spend is a little over one loaded junior-engineer salary buying a parallel workforce, with actual cash lower still, since most of the volume rides flat subscriptions. When we want more shipped work on those processes, we turn that dial.
For everything else, the dial buys thrashing.
The fork is not the model. It is whether the goal is named.
That conditionality is the point, not a caveat. Task length that agents complete reliably doubles roughly every seven months — the models will keep raising the solid curve. Only naming goals moves you off the dashed one.
The ladder
Borrowing the shape of SAE's driving levels, company autonomy is just goal abstraction climbing:
- L0 — humans do the work.
- L1 — agents do tasks under constant steering. Most teams are here.
- L2 — trajectories complete known goal classes; humans review summaries.
- L3 — the system proposes goals from signals; humans approve.
- L4 — goals cascade into sub-goals with sparse checkpoints.
Trajectory literacy is the rung between L1 and everything above it. You cannot propose goals from signals (L3) without a history of what comparable goals cost — and you cannot have that history if your four PRs never knew they were one thing.
Companion post: Customer Zero Is an Agent — what trajectory literacy demands from the product you ship and the codebase you keep.