Agent quality is becoming a workflow-and-trace problem.

Résumé

Vercel and GitHub are treating the efficiency of agentic workflows as an engineering performance problem, not merely an API-billing issue.

Vercel has added deeper visibility into subagent activity and distributed traces. GitHub, meanwhile, redesigned the workflow and tool instructions behind Copilot code review, lowering its average review cost by roughly 20% without reducing review quality. Together, the updates suggest that agent performance increasingly depends on how workflows are structured, instrumented, and debugged—not just on which model is used.

Key updates

* Vercel Agent Runs can now expose subagent activity for eve projects. A new Subagents tab organizes delegated runs by the turn that launched them and shows each subagent’s prompt, duration, failures, tool calls, cost, and token usage.

* Vercel traces now have Tree and Waterfall views. Tree view exposes parent-child span relationships, while Waterfall view shows chronological execution, parallel work, critical paths, and where time was lost.

* GitHub reduced Copilot code review’s average cost by roughly 20% while maintaining review quality. The improvement came from rewriting tool instructions around a review-specific workflow, rather than simply replacing or upgrading tools.

* GitHub’s traces revealed an inefficient browsing loop. The agent searched too broadly, guessed paths, opened unnecessary files, and carried excess tool output into later reasoning. GitHub changed the workflow to start from the pull-request diff, narrow the search, and read only the evidence needed to evaluate a specific concern.

Why it matters

Agentic AI is moving from a productivity feature into production workflow infrastructure.

When agents run automatically inside pull requests, code reviews, CI/CD pipelines, support systems, or internal operations, token usage begins to resemble compute or observability spend. But the cost is not determined only by model pricing. It also depends on workflow behavior:

- How much context the agent loads

- Whether searches stay focused or expand unnecessarily

- How many tool calls and retries occur

- Whether subagents duplicate work

- How failures alter the rest of the execution

- Whether intermediate outputs remain in the context window

GitHub’s example is especially important because better tools initially made the system both more expensive and less effective. The problem was not the capability of the tools; it was that their instructions encouraged a general repository-browsing workflow rather than a focused code-review workflow. Tracing exposed that mismatch.

Builder takeaway

Treat agent execution traces and token usage as first-class operational signals.

For every automated workflow, measure:

- Invocation frequency and trigger conditions

- Input and accumulated context size

- Model, tool, and subagent costs

- Tool-call count, latency, errors, and retries

- Parallel versus sequential execution

- Repeated or unnecessary context retrieval

- Output quality and successful task completion

- Cost per useful outcome, not merely cost per run

The goal should not be to minimize tokens in isolation. It should be to remove tokens, tool calls, and steps that do not improve the result.

Build that observability before deploying agents across every pull request or internal process. Otherwise, inefficient behavior will scale alongside adoption—and teams may struggle to distinguish model problems from workflow, prompt, tool, or orchestration problems.