The drift toward “just let the agent decide”
Early agentic systems often worked by giving a model a goal and a set of tools and watching what happened. The appeal was obvious: describe the outcome, skip the implementation. The problem was equally obvious in hindsight — unpredictable paths, cascading errors, and in any environment where compliance actually matters, a near-total inability to audit what happened and why.
The more durable pattern that has emerged is something less cinematic but considerably more useful: treat deterministic code as the spine of a workflow, and call a language model only at the steps where reasoning is genuinely required.
What Orbit does differently
Flywire — a payments company operating across 240 countries under PCI DSS and SOC 2 compliance — faced a version of this problem directly when building Orbit, their internal agentic workflow platform. Sensitive payment data cannot leave their controlled infrastructure. Audit trails are not optional. A rogue agent loop that spirals into unexpected tool calls is not an inconvenience; it is a compliance event.
Their answer was architectural: every workflow lives in a YAML file, version-controlled in Git, reviewed via merge request like any other code. LLM steps enforce strict JSON output schemas — if a model returns something that does not validate, the system retries or falls back before continuing. Each step declares upfront which tools, network access, and MCP servers (a protocol that lets models interact with external services) it is allowed to use. A code review step can read and search the codebase but cannot edit files or push changes.
Guard rails are baked in by default, not bolted on later: per-agent timeouts, rate limits aggressive enough to prevent runaway spawning, and concurrency locks that drop a duplicate request if one is already running.
The result after 30 days in production: 11,000 workflow executions at a 99 percent success rate.
The skill-first path to automation
One of the more transferable ideas in Orbit’s design is the promotion path from skill to workflow. Flywire maintains a central skill repository — reusable, composable LLM behaviors — that engineers can call from both their own local sessions and from automated Orbit workflows running in production.
The recommended sequence is: write a skill first. Skills are cheap to write and useful immediately; they let practitioners validate that a task is worth automating before committing to the infrastructure of a full workflow. Once the task is proven — once the behavior is understood and the edge cases are documented — the predictable parts get crystallized into deterministic code, and only the reasoning steps that genuinely benefit from a model remain as LLM calls.
This is the opposite of the instinct to reach for a fully autonomous agent first and tune it into submission. Starting small and promoting deliberately produces systems that are easier to debug, audit, and improve.
Evaluation without the ceremony
Orbit’s approach to evaluating agent behavior is also worth noting. Every execution is traced end-to-end using OpenTelemetry (a standard for recording what happened inside a system — think of it as a structured log that captures every model call, tool call, and activity in sequence). Real production traces are extracted into golden datasets, versioned alongside the workflow code, and run on demand whenever a prompt or model changes.
No elaborate evaluation infrastructure. No synthetic benchmarks. Just real traces, versioned like code, compared before and after a change. The roadmap points toward closing the loop further — running the full evaluate-deploy-monitor cycle inside the platform itself, without needing a re-deploy for every improvement.
The constraint is the feature
There is a broader principle here that extends well beyond regulated financial environments. The systems that have proven most useful in practice tend to be the ones where the scope of what an agent can do has been deliberately narrowed — not because the teams behind them lacked ambition, but because a narrow, reliable agent that runs 11,000 times at 99 percent success is far more valuable than a capable one that occasionally goes off-script in ways that are hard to explain after the fact.
The next generation of these platforms will likely extend this pattern rather than abandon it: better sandboxing so agents can run full test suites in isolation, resumable sessions for multi-step tasks that span hours or days, and evaluation tooling that treats production behavior as the ground truth rather than a proxy metric.
The direction is not toward more autonomy, necessarily. It is toward better-defined autonomy — knowing precisely what an agent is allowed to do, measuring what it actually does, and tightening the loop between the two.
Text summarized and optimized using Anthropic’s models and reviewed by a human.