# Agents in Orbit: Workflows, Not Autopilot — Eduardo Simon & Javier Casal, Flywire

## Executive summary

Flywire introduced Orbit, an internal platform designed to integrate LLM steps into deterministic engineering workflows, ensuring control and reliability in a highly regulated payment processing environment. Orbit defines agents using YAML/JML files that undergo standard merge request reviews, allowing AI to supply judgment while keeping predictable logic in code. The architecture separates orchestration, execution, and session state, and enforces strict guardrails (timeouts, rate limits, network access) to ensure safety and compliance (PCI, DSS). This approach allows for scaling automation—such as code review and dependency fixing—while keeping human review in the loop.

## Key takeaways

- Workflows, Not Autopilot: Orbit pairs deterministic code with small LLM steps, calling the model only when reasoning is necessary. This ensures that predictable procedural logic remains in code, maintaining reliability and control.
- Compliance and Infrastructure Control: By building the platform in-house and keeping execution within the existing Victoria infrastructure, Flywire ensures that sensitive data (PCI, PII, PHI) never leaves their controlled environment, bypassing lengthy vendor security reviews.
- Structured Evaluation and Improvement: The platform uses isolated component evaluation by injecting historical state and context into specific workflow nodes, rather than evaluating entire end-to-end workflows. Golden datasets are versioned in the repository for on-demand testing.
- Adoption Strategy: Skill to Workflow: The recommended adoption path is to start with a 'Skill' (which is cheap and easy to iterate on), prove its value, and then formalize it into a deterministic 'Workflow' (JML file).

## Technical details

- Architecture and Components: The architecture separates the orchestration layer, the agent runtime environment, and the session state into distinct components for improved isolation and scalability. The platform utilizes AWS Lambda microVMs (managed microVMs) for agent execution, allowing processes to pause and resume.
- Workflow Definition and Control: Every agent is defined in a single JML file that follows the standard merge request review process. Control is enforced by restricting four elements for every step: the network, the tools, the skills, and the MCP servers. These restrictions are declared in the YAML file itself.
- Reliability and State Management: Systemic reliability is guaranteed by enforcing strict JSON schemas for all LLM step responses. This constrains output formats, ensuring subsequent execution branches and state transitions are driven by deterministic control flow. The platform also implements timeouts, rate limits, and locks to prevent misuse.
- Tooling and Integration: The platform reuses the Cloud Code Agents SDK for the LLM harness, providing mature tools for tool usage and sub-agents. Skills are managed centrally via an internal Cloud Code plug-in marketplace, ensuring consistency across both local development and automated workflows.

## Practical implications

- The platform supports diverse use cases, including code review, translation updates, dependency fixes, ticket triage, and bulk repository changes, demonstrating software engineering at scale.
- The adoption path emphasizes starting with high-impact, repetitive tasks (e.g., daily code reviews, fixing vulnerable dependencies) to build confidence and prove value.
- The ability to run workflows in the background reduces context switching for engineers, allowing them to focus on high-value work.

## Topics

Workflow Automation, LLM Orchestration, DevOps, Compliance Engineering, Software Architecture, Eduardo Simon, Javier Casal

Source: https://www.youtube.com/watch?v=rAUyRDOFyHU