AI Engineer · Published 2026-10-12

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

privateReview: unreviewedConfidence: high
agentsworkflowsyamlcomplianceevaluationsagent-workflowsyaml-defined-agentsclaude-agent-sdkcapability-restrictionstructured-outputsstep-level-evaluationmicrovm-sandboxing
Open on YouTube ↗

Summary

Overview

  • Speaker: Eduardo Simon & Javier Casal
  • Channel: AI Engineer
  • Main topic: Building practical, structured, and compliant AI agent workflows in-house at Flywire
  • Purpose: To share Flywire's engineering journey and technical architecture for building practical, compliant, and reliable AI agent workflows rather than open-ended LLM loops. Eduardo Simon and Javier Casal from Flywire discuss their AI platform 'Orbit', which transitions AI agents from open-ended autonomous 'autopilot' loops into structured, workflow-driven tools. Operating in the heavily regulated global payments space (PCI DSS, SOC II), Flywire requires strict security, data privacy, and deterministic control. Orbit uses YAML-defined workflows, reuses the Claude Agent SDK with strict network, tool, and skill restrictions, and implements isolated evaluations and YAML-first developer tooling.

Topic Map

Context and Compliance at Flywire

  • Explanation: Introduction to Flywire's scale (5300+ clients, 240+ countries) and the absolute necessity of strict compliance frameworks like PCI DSS and SOC II when handling high-value global payments.
  • Key claims:
    • Regulatory compliance, privacy, and security are core requirements, not optional.
    • Customer data, PII, and payment details must remain completely safe.
  • Examples:
    • Processing transactions across education, healthcare, travel, and B2B.
  • Terminology:
    • PCI DSS
    • SOC II
    • PII
    • PHI
  • Why it matters: Financial enterprises cannot pass sensitive payment data to ungoverned third-party endpoints without strict architectural boundaries.

Orbit: The Toil Killer

  • Explanation: Orbit is Flywire's internal platform that eliminates daily engineering repetitive tasks by combining deterministic code with structured LLM workflow steps.
  • Key claims:
    • Instead of open-ended LLM loops, Orbit pairs deterministic code with small LLM steps.
    • Repetitive procedural logic is written in code, and LLMs are called only where reasoning is needed.
  • Examples:
    • Code review agents, linter fixes, translation workflows, and support ticket triage.
  • Terminology:
    • Orbit
    • toil killer
    • workflow-oriented
  • Why it matters: Reduces AI token usage, costs, and unpredictability while ensuring enterprise-grade reliability.

Anatomy of a Workflow & YAML-First Authoring

  • Explanation: Every agent in Orbit is defined by a single YAML file in the repository that goes through merge request reviews just like any other code.
  • Key claims:
    • Workflows start with a trigger (webhook, API, schedule), execute deterministic steps, and use strict LLM steps with bounded permissions.
    • YAML is familiar to engineers and keeps the codebase AI-friendly.
  • Examples:
    • Code review agent triggered by a GitLab webhook.
  • Terminology:
    • YAML
    • merge request review
    • trigger
    • deterministic steps
  • Why it matters: Enables engineers to read, write, and review agent workflow definitions as easily as regular application code.

Technical Architecture: Victoria, Fargate, and MicroVMs

  • Explanation: Evolution from a single ECS Fargate container containing harness and runtime to separated layers: Orchestration, Agent Runtime, and Session State, leveraging AWS Lambda microVMs.
  • Key claims:
    • Separating orchestration, runtime, and session state improves isolation, maintainability, and resource allocation.
    • Fargate limits like lack of package managers are solved using AWS Lambda microVMs for resumable, isolated execution.
  • Examples:
    • Timeouts, rate limits, and concurrency locks to prevent runaway agent spawning.
  • Terminology:
    • Victoria
    • ECS Fargate
    • AWS Lambda MicroVMs
    • Orchestration layer
  • Why it matters: Ensures scalability, cost control, and sandboxing across thousands of parallel agent executions.

Reusing the Claude Agent SDK with Limits

  • Explanation: Flywire reuses the harness behind Claude Code (Claude Agent SDK) out-of-the-box and adds control layers on top.
  • Key claims:
    • Restricts network access, available tools, skills, and MCP servers per step in the YAML file.
    • Focuses engineering effort on workflow definition rather than building custom harnesses.
  • Examples:
    • Code review step can read and search code but cannot edit files or push changes.
  • Terminology:
    • Claude Agent SDK
    • MCP servers
    • harness
  • Why it matters: Leverages mature, well-tested agent harnesses while maintaining strict enterprise security controls.

Evaluations: Structured Outputs and Isolated Evals

  • Explanation: Reliability is achieved through strict JSON schemas for model responses and isolated component evaluation using historical state.
  • Key claims:
    • Strict JSON schemas ensure downstream execution branches are driven by deterministic control flow.
    • Evaluating individual LLM steps using historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.
  • Examples:
    • Schema validation triggering automatic retry or fallback paths.
  • Terminology:
    • Structured outputs
    • JSON schema
    • isolated evaluation
    • golden dataset
  • Why it matters: Solves the noisiness and high cost of traditional synthetic end-to-end benchmark evaluations.

Key Points

Workflows, Not Autopilot

  • Explanation: AI agents should operate within structured, deterministic workflows rather than free-roaming open-ended loops.
  • Evidence: Orbit pairs deterministic code with small LLM steps, calling models only when reasoning is needed.
  • Practical implication: Improves control, safety, and reliability while reducing costs.

YAML-First Developer Experience

  • Explanation: Defining agents in YAML files allows engineers to use existing Git workflows and merge request reviews.
  • Evidence: Every agent in Orbit is a single YAML file reviewed like any other code.
  • Practical implication: Lowers adoption barrier for engineering teams and keeps codebase AI-friendly.

Isolated Component Evaluation

  • Explanation: Testing individual LLM workflow steps with historical state rather than full end-to-end runs.
  • Evidence: Injecting exact historical state and context directly into workflow nodes.
  • Practical implication: Makes evaluating model output quality, prompt adjustments, and regression catching cheaper and faster.

Frameworks, Models & Processes

Orbit Workflow Framework

  • How it works: Combines deterministic code triggers, structured activities, and constrained LLM steps defined in YAML.
  • Components:
    • Trigger (API, Webhook, Schedule, MCP server)
    • Deterministic steps (metadata fetching, risk tiering, cloning)
    • LLM step (read-only tools, strict JSON schema output)
    • Deterministic output handler (posting back findings)
  • When to use: Automating repetitive internal engineering tasks like code reviews, dependency updates, and ticket triage.

Examples & Case Studies

Building the Victoria Linter Fixer agent

  • Illustrates: Automated code review and refactoring across hundreds of repositories
  • Lesson: Automating linter findings fixes saves thousands of manual engineering hours.

Actionable Takeaways

  • Immediate:
    • Start small with high-impact, repetitive tasks like code review or linter fixes.
    • Enforce strict JSON schemas on all LLM outputs to guarantee deterministic downstream control flow.
    • Use YAML for workflow definitions to integrate smoothly with existing CI/CD and MR processes.
  • Strategic:
    • Build internal platforms (like Orbit) to keep sensitive data within your secure environment.
    • Separate orchestration, runtime, and session state to scale agent infrastructure independently.
    • Move from vibe checks to versioned golden datasets extracted from real OpenTelemetry execution traces.
  • Questions to investigate:
    • How can full container sandboxing (Docker-in-Docker) be achieved securely at scale?
    • How to implement automated model routers for cost-aware multi-vendor model selection?

Claims Worth Verifying

  • Over 9,000 code review agent runs completed in the last 30 days averaging under 3 minutes per merge request. (Metric / Operational Impact)
  • Over 11,000 total workflow runs across Flywire engineering with a 99% success rate. (Metric / Operational Impact)

Notable Quotes

"Agents in Orbit: Workflows, Not Autopilot" (at 0:00) "Orbit is an internal platform that eliminates daily engineering repetitive tasks by including LLMs directly into structured workflows." (at 5:05)

Compressed Summary

  • Orbit combines deterministic code with structured LLM workflow steps.
  • Agents are defined in YAML and reviewed via standard merge requests.
  • Strict JSON schemas and isolated step evaluations guarantee reliability.
  • Reusing Claude Agent SDK with strict tool and network bounds ensures security.
  • Keywords: agents, workflows, yaml, compliance, evaluations
  • Core insight: Structured, workflow-driven automation transforms AI agents into reliable, secure force multipliers for enterprise engineering teams.

Core insights

7
Architecturehigh noveltymoderate evidence

Agent capability should be bounded per workflow step, not per agent: each LLM step declares its own allowed network access, tools, skills, and MCP servers in the YAML definition, so the same harness can be read-only in one step and write-capable in another.

Why it matters

Least-privilege at step granularity shrinks the blast radius of a single bad model decision without requiring a separate agent per permission set, and makes permission review a plain code-review activity.

Generalization

Treat tool/network permissions as a per-node property of the workflow graph rather than a global config of the agent runtime; this composes with any harness that supports tool allowlists.

Restricts network access, available tools, skills, and MCP servers per step in the YAML file.
Open source video
Code review step can read and search code but cannot edit files or push changes.
Open source video
Practicehigh noveltymoderate evidence

The reliability unit is the LLM step, not the end-to-end agent: individual steps are evaluated by injecting the exact historical state and context captured from production into that node, instead of constructing synthetic end-to-end scenarios.

Why it matters

Historical-state replay makes prompt changes and model swaps cheaply testable and regression-detectable, addressing the cost and noisiness that make synthetic end-to-end benchmarks impractical for internal automation.

Generalization

Persist per-node inputs from real runs as a replay corpus; evaluations then become unit tests over a workflow graph rather than integration tests over a stochastic whole.

Evaluating individual LLM steps using historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.
Open source video
Injecting exact historical state and context directly into workflow nodes.
Open source video
Mechanismmedium noveltymoderate evidence

Strict JSON schemas convert an unreliable free-text model call into a typed contract, so downstream branching, retries, and fallbacks are handled by deterministic control flow rather than by the model.

Why it matters

Validation failure becomes an explicit, observable error path (retry or fallback) instead of silent semantic drift propagating through the pipeline, which is what makes deterministic orchestration around LLM steps actually safe.

Generalization

Any place where you would branch on model output should be a schema-validated boundary; treat schema violations as a first-class failure mode with a defined recovery path.

Strict JSON schemas ensure downstream execution branches are driven by deterministic control flow.
Open source video
Schema validation triggering automatic retry or fallback paths.
Open source video
Practicemedium noveltystrong evidence

Agent definitions are promoted to repository artifacts: one YAML file per agent, merged and reviewed through the same merge-request process as application code.

Why it matters

It co-opts existing Git governance, review, and audit trails for agent behavior, which is the cheapest way to make AI behavior change-controlled in a regulated environment, and it raises readability for engineers who must debug or amend workflows.

Generalization

Prefer declarative, diffable agent specifications over UI-configured or prompt-string-defined agents wherever reviewability and audit history are requirements.

Every agent in Orbit is defined by a single YAML file in the repository that goes through merge request reviews just like any other code.
Open source video
YAML is familiar to engineers and keeps the codebase AI-friendly.
Open source video
Architecturemedium noveltymoderate evidence

The agent runtime was decomposed from a single container hosting both harness and runtime into three separated layers (orchestration, agent runtime, session state), with session state made resumable on AWS Lambda microVMs because the container platform lacked package managers.

Why it matters

Separating session state from execution is what enables resumption and isolated sandboxing per run, and it means orchestration can scale independently of the compute that hosts agent sessions.

Generalization

Design agent platforms so that execution is ephemeral and state is externalized; then isolation, resumability, and concurrency control become separate, independently tunable concerns.

Evolution from a single ECS Fargate container containing harness and runtime to separated layers: Orchestration, Agent Runtime, and Session State, leveraging AWS Lambda microVMs.
Open source video
Fargate limits like lack of package managers are solved using AWS Lambda microVMs for resumable, isolated execution.
Open source video
Tradeoffmedium noveltymoderate evidence

Reusing a mature agent harness (the Claude Agent SDK, the harness behind Claude Code) out-of-the-box shifts engineering effort from harness construction to workflow definition and control layers.

Why it matters

The build-versus-adopt decision for the harness is where most agent teams burn time; adopting a proven loop and constraining it externally is a materially cheaper path to production than writing a bespoke reasoning loop.

Generalization

Constrain an adopted agent loop from the outside (permissions, schemas, step boundaries) rather than reimplementing the loop; reserve custom harness work for cases where the control surface is genuinely absent.

Flywire reuses the harness behind Claude Code (Claude Agent SDK) out-of-the-box and adds control layers on top.
Open source video
Focuses engineering effort on workflow definition rather than building custom harnesses.
Open source video
Failure Modemedium noveltyweak evidence

Runaway agent spawning is treated as an operational failure mode addressed with floor-level controls—timeouts, rate limits, and concurrency locks—rather than with better prompting.

Why it matters

Concurrency control is the difference between a bounded cost envelope and an unbounded one when thousands of workflow executions can fan out; these controls belong in the orchestration layer, not in the agent's reasoning.

Generalization

Any system where an agent can request more agents/compute needs explicit admission control at the orchestrator; treat fan-out as a capacity-planning problem, not a model-behavior problem.

Timeouts, rate limits, and concurrency locks to prevent runaway agent spawning.
Open source video

Deep dives

4

Enforcement layer for per-step capability grants

Research question

When a workflow node is granted a read-only tool set, at which layer (harness allowlist, sandbox syscall/filesystem boundary, or orchestrator) must the restriction be enforced so that tool chaining, MCP servers, or prompt injection cannot escalate to file writes or network egress?

Why

Per-step least privilege is only worth the YAML complexity if the restriction is adversarially sound; if the boundary lives in the prompt or the harness's cooperative tool filter, a compliant-looking workflow file is a false sense of security in a PCI/SOC-scoped environment.

Restricts network access, available tools, skills, and MCP servers per step in the YAML file.
Open source video
Code review step can read and search code but cannot edit files or push changes.
Open source video
Source video

Correlation between step-level replay evals and end-to-end workflow outcomes

Research question

Do regressions detected by replaying historical state into individual LLM steps predict actual end-to-end workflow failures in production, and what is the false-negative rate of a step-only eval suite relative to end-to-end scenario testing?

Why

The whole economic argument for step-level evaluation rests on an unmeasured assumption of agreement; if step replay systematically misses cross-step interaction failures, teams will ship regressions that their tests declare green.

Evaluating individual LLM steps using historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.
Open source video
Injecting exact historical state and context directly into workflow nodes.
Open source video
Source video

Schema violations as a first-class failure mode with a recovery budget

Research question

What is the observed schema-validation failure rate per LLM step in production, and how should the retry/fallback split be budgeted so that a failing step degrades deterministically instead of converting into retry storms or silent semantic drift?

Why

Schemas are described as the bridge that makes probabilistic output safe to branch on, but the operational cost of that bridge (retry latency, token spend, fallback quality) determines whether the boundary is a control or just a tax.

Strict JSON schemas ensure downstream execution branches are driven by deterministic control flow.
Open source video
Schema validation triggering automatic retry or fallback paths.
Open source video
Source video

Expressivity ceiling of a single-file declarative agent spec

Research question

At what workflow complexity (loop depth, dynamic fan-out, conditional branching over structured state) do authors of YAML-defined agents start needing escape hatches into general-purpose code, and how much reviewability is lost when they do?

Why

The governance benefit of YAML-reviewed agents is bounded by the schema's expressiveness; knowing where that ceiling sits tells teams when to split a workflow versus when to reach for code, and prevents the schema from becoming a leaky abstraction with hidden scripts.

Every agent in Orbit is defined by a single YAML file in the repository that goes through merge request reviews just like any other code.
Open source video
YAML is familiar to engineers and keeps the codebase AI-friendly.
Open source video
Source video

Article ideas

4

Least Privilege Belongs on the Workflow Node, Not the Agent

Granularity of the permission boundary, not the strength of the model, determines the blast radius of an agent failure; declaring tools, network, and MCP access per step lets one harness be read-only in one node and write-capable in another, which is strictly better than either a globally-permissioned agent or a fleet of single-purpose agents each with its own deploy surface.

Angle

Reframe agent permissions as a property of a node in a workflow graph rather than a property of the runtime, and show why that composes with code review, rollback, and audit in a way that global allowlists cannot.

Source video

Your Agent Evals Are Integration Tests When They Should Be Unit Tests

Teams building agent workflows default to synthetic end-to-end scenarios because that is the only test shape they know, then abandon evals as too expensive and too noisy; capturing per-step inputs from real production runs and replaying them turns each node into a regression unit test, and the residual risk of missed cross-step interactions is a measurable quantity rather than an article of faith.

Angle

Argue for a record-and-replay eval pyramid over agent workflow graphs, and specify what must be captured per node to make replay faithful (state, context, tool observations, not just the prompt).

Source video

Adopt the Loop, Own the Control Plane

The build-versus-adopt question for an agent harness is usually answered wrong: teams reimplement a reasoning loop they cannot maintain and then have no budget left for the control layers that actually determine whether the system is safe. Reusing a mature harness and constraining it externally with per-step permissions, strict schemas, and step boundaries moves engineering effort to the only part that is genuinely yours.

Angle

Frame the architecture as an adopted, untrusted reasoning core surrounded by an owned control plane, and enumerate what must be built on the outside to make that posture defensible.

Source video

YAML Is a Governance Surface, Not a Config Format

Declarative agent specs are worth their constraints because they co-opt Git as the audit, review, and rollback mechanism for AI behavior; the win is not readability but the fact that a behavior change becomes a diffable merge request, and the cost is a hard expressivity ceiling that teams should plan for instead of discovering mid-migration.

Angle

Position agent specification files as infrastructure-as-code and derive the concrete review practices (blast-radius review, permission diffs, rollback) that follow for free.

Source video

Project ideas

3

StepBoundary

gatehouse

A workflow node granted only read tools can be driven to perform a file write or outbound network call via tool chaining, MCP server invocation, or injected instructions when the restriction is enforced at the harness allowlist layer, but cannot when the same grant is enforced at the sandbox boundary — so the escape rate is a function of enforcement layer, not of the permission declaration.

Proof of concept

Build a minimal 3-step YAML workflow (read-only code search node, reasoning node, write node) running on a containerized agent harness, implement the per-step restriction twice — harness tool-allowlist only, and harness allowlist plus a syscall/egress-denying microVM sandbox — and run a fixed red-team suite of escalation attempts (MCP shim, prompt injection in retrieved file content, tool-argument confusion) against both configurations.

Measurement

Successful escapes per 100 attempts per enforcement layer, broken down by attack vector; a nonzero harness-only rate with a zero sandbox rate confirms the hypothesis, while any sandbox escape falsifies it.

Source video

Replay Agreement Study

beyond-evals

Step-level replay evaluations rank a set of candidate prompt/model changes in the same order as end-to-end workflow evaluations with high agreement, but under-report failures whose cause is inter-step interaction — giving a measurable false-negative rate rather than an assumed one.

Proof of concept

Instrument a 4-5 step internal workflow to persist per-node inputs and outputs from production, build a replay harness that injects historical state into single nodes, then take 20 candidate changes (prompt edits, model swaps) and evaluate each both by step-level replay and by end-to-end runs on a held-out set of real trigger events.

Measurement

Spearman rank correlation between step-level and end-to-end pass rates across the 20 changes, plus the count of changes that pass all step replays but fail end-to-end; report the false-negative rate and per-evaluation cost delta.

Source video

Schema Recovery Budget

new

Schema-validation failures cluster in a small number of steps and failure classes, so a per-step recovery policy tuned to the observed failure taxonomy (bounded retry for malformed output, fallback for semantic mismatch) reduces failed workflow runs more than a uniform retry-everything policy at lower token cost.

Proof of concept

Instrument a schema-validated workflow to log every validation failure with the offending payload and the resolved recovery path, classify failures into malformed-JSON, missing-field, enum-mismatch, and semantically-wrong-but-valid, then A/B a uniform 3x retry policy against a class-specific retry/fallback policy.

Measurement

Validation failure rate per step, recovery success rate and additional tokens consumed per failure class, and end-to-end workflow completion rate under each policy; the hypothesis holds if class-specific recovery improves completion rate at lower mean token cost per successful run.

Source video

Architectural implications

3

Responsibility for control flow is moved out of the LLM and into deterministic code that invokes small, bounded LLM steps.

Before

An autonomous agent loop decides its own next action, tool, and termination condition.

After

A workflow skeleton of deterministic steps owns sequencing; the LLM is called only at nodes where reasoning is required, with typed input and schema-validated output.

Consequence

Cost and token usage drop, behavior becomes reproducible and debuggable, and failures localize to a single node—at the cost of losing open-ended exploration capability.

Source video

Session state is externalized from the runtime, separating orchestration, agent runtime, and session state.

Before

A single ECS Fargate container holds both the harness and the runtime, so a run's lifespan is tied to one container.

After

Orchestration schedules work; execution happens in isolated, resumable microVMs; session state is addressable independently.

Consequence

Parallel agent executions can be sandboxed and resumed, but the platform now needs explicit state serialization and lifecycle management.

Source video

The agent specification file becomes the unit of review and governance.

Before

Agent behavior is defined in prompts or UI configuration, outside normal code review and change management.

After

Each agent is a single YAML file in the repository, reviewed through merge requests like any other code.

Consequence

Audit trails, rollback, and blast-radius review come for free from the Git workflow—but expressiveness is capped by what the YAML schema can represent.

Source video

Tradeoffs and failure modes

4

Workflow rigidity versus agent autonomy

Benefit

Deterministic control, safety, lower token cost, and reviewable behavior in a regulated domain.

Cost or risk

Workflows that hit an unanticipated situation have no path forward unless the YAML author anticipated it; open-ended discovery tasks are out of scope by construction.

Instead of open-ended LLM loops, Orbit pairs deterministic code with small LLM steps.
Open source video
Source video

Isolated step evaluation versus end-to-end validity

Benefit

Cheaper, more reproducible, and faster regression detection on prompt and model changes.

Cost or risk

Step-level replay with historical state can miss failures that only emerge from interaction between steps, and the historical corpus encodes past distributions rather than new inputs.

Evaluating individual LLM steps using historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.
Open source video
Source video

Adopting a third-party harness

Benefit

Mature, well-tested agent loop without building one; engineering effort goes to workflow definition.

Cost or risk

Security guarantees depend on externally applied control layers (network, tool, skill, MCP restrictions), and the team inherits the vendor's abstraction and release cadence.

Leverages mature, well-tested agent harnesses while maintaining strict enterprise security controls.
Open source video
Source video

Platform substrate choice (Fargate vs Lambda microVMs)

Benefit

MicroVMs restore missing package-manager capability and provide resumable, isolated execution.

Cost or risk

Introducing a second compute substrate alongside Fargate increases operational surface area and adds state-handoff complexity between runtime and session store.

Fargate limits like lack of package managers are solved using AWS Lambda microVMs for resumable, isolated execution.
Open source video
Source video

Open questions

4

What is the expressivity ceiling of a single-YAML-file agent definition before workflows need real programming-language constructs (loops, dynamic fan-out, conditionals over structured state)?

Why unresolved

The summary describes YAML authoring as beneficial but gives no account of workflows that outgrew the schema or how those were handled.

Research direction

Prototype a mid-complexity workflow in YAML versus code and measure authoring time, review comments, and number of escape hatches needed.

Source video

How well does isolated step-level evaluation correlate with end-to-end workflow success in production?

Why unresolved

The summary asserts isolated evals are cheaper and more reproducible but reports no measured agreement with end-to-end outcomes.

Research direction

Run both eval modes on the same change sets and compute ranking agreement between step-level regressions and end-to-end failures.

Source video

What is the latency and cost penalty of separating orchestration, runtime, and session state on microVMs compared with a single-container design?

Why unresolved

The architecture shift is described qualitatively (improved isolation, maintainability, resource allocation) with no numbers.

Research direction

Benchmark cold-start, resume-from-state, and per-execution overhead across the monolith and split architectures at realistic concurrency.

Source video

How are per-step tool and network restrictions actually enforced—at the harness, the sandbox, or the orchestration layer—and can a model step circumvent them?

Why unresolved

The summary states restrictions exist but not the enforcement mechanism or its adversarial test results.

Research direction

Red-team a step given a read-only tool grant and attempt network/file-write exfiltration through MCP servers or tool chaining.

Source video

Key claims

8
causalVerification needed

Pairing deterministic code with small LLM steps reduces token usage, cost, and unpredictability relative to open-ended loops.

Evidence

Reduces AI token usage, costs, and unpredictability while ensuring enterprise-grade reliability.

Question

What is the measured token and dollar delta per task between the workflow design and an autonomous-loop baseline on the same task set?

Source video
factualVerification not requested

Every agent in Orbit is defined by a single YAML file that is reviewed through merge requests like ordinary code.

Evidence

Every agent in Orbit is defined by a single YAML file in the repository that goes through merge request reviews just like any other code.

Source video
causalVerification needed

Per-step restriction of network access, tools, skills, and MCP servers is the mechanism that makes reusing an external harness compliant.

Evidence

Restricts network access, available tools, skills, and MCP servers per step in the YAML file.

Question

What enforcement layer applies these restrictions, and has circumvention been tested?

Source video
factualVerification not requested

Steps can be granted asymmetric capability: a code-review step may read and search code but not edit files or push changes.

Evidence

Code review step can read and search code but cannot edit files or push changes.

Source video
comparativeVerification needed

Evaluating individual LLM steps with injected historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.

Evidence

Evaluating individual LLM steps using historical state is cheaper and more reproducible than end-to-end synthetic benchmarks.

Question

How much cheaper per evaluation, and what is the false-negative rate versus end-to-end testing?

Source video
causalVerification needed

Strict JSON schemas with validation-triggered retry or fallback keep downstream branches on deterministic control flow.

Evidence

Strict JSON schemas ensure downstream execution branches are driven by deterministic control flow.

Question

What schema-validation failure rate is observed in production, and how often does retry versus fallback resolve it?

Source video
causalVerification needed

Automating linter-finding fixes via an agent saves thousands of manual engineering hours.

Evidence

Automating linter findings fixes saves thousands of manual engineering hours.

Question

How were hours saved quantified, and what fraction of agent-proposed fixes were merged versus rejected?

Source video
causalVerification needed

Separating orchestration, runtime, and session state improves isolation, maintainability, and resource allocation.

Evidence

Separating orchestration, runtime, and session state improves isolation, maintainability, and resource allocation.

Question

Which of these improvements were measured, and at what added latency or operational cost?

Source video

Connections

5