Orchard: An Open-Source Agentic Modeling Framework

The paper introduces Orchard, an open-source framework featuring a lightweight environment layer (Orchard Env) and specialized training recipes that enable scalable, high-performance agentic modeling across coding, GUI, and personal assistant domains, achieving state-of-the-art results among open-source models.

The Gist

The Big Idea: Building a Universal "Playground" for AI

Imagine you want to teach a robot to do complex jobs, like fixing a broken computer program, navigating a website to buy groceries, or managing your email. To learn, the robot needs to practice in a safe, isolated "sandbox" (like a video game level) where it can try things, make mistakes, and see what happens without breaking the real world.

For a long time, building these sandboxes has been like building a custom playground for every single toy. If you wanted to test a coding robot, you built one playground. If you wanted to test a shopping robot, you had to build a completely different one from scratch. This made research slow, expensive, and hard to share.

Orchard is a new open-source framework that solves this by building one universal, high-quality playground that works for any type of robot agent. The researchers call this the "Orchard Env."

Think of Orchard as a universal power strip and tool belt for AI researchers. Instead of building a new electrical outlet for every device, they built one smart outlet that works with everything. This allows researchers to focus on teaching the AI how to think, rather than worrying about the plumbing of the sandbox.

---

The Three "Recipes" (What They Built)

Using this universal playground, the team cooked up three different "recipes" to train AI agents in three specific areas. They didn't just build the kitchen; they showed how to make three distinct, delicious meals.

1. Orchard-SWE: The "Junior Developer" Agent

• The Job: Fixing bugs in software code.
• The Challenge: Coding is hard. Sometimes an AI gets stuck or makes a mistake halfway through. Most training methods only look at the "perfect" solutions and throw away the failed attempts.
• The Orchard Trick: They used a technique called "Credit-Assignment." Imagine a student failing a math test. Instead of just throwing the test away, a teacher looks at the paper and says, "You got the first three steps right! That was good." Orchard does this with AI. It saves the "good parts" of failed attempts and teaches the AI to recognize those successful steps.
• The Result: They trained a model that is as good at fixing code as much larger, more expensive models, but it learned from a mix of successes and "almosts."

2. Orchard-GUI: The "Browser Navigator" Agent

• The Job: Clicking through websites, filling out forms, and finding products (like finding a dog bed on Amazon).
• The Challenge: Websites are visual. The AI has to "see" a screenshot and figure out where to click. It's like teaching someone to drive by only showing them pictures of the road.
• The Orchard Trick: They trained a small, efficient model (only 4 billion parameters, which is tiny for an AI) using a mix of practice runs and a "judge" (another AI) that grades the results. They didn't need millions of examples; they used a carefully curated set of about 2,600 tasks.
• The Result: This small model became the strongest open-source browser agent ever made. It performed as well as (and sometimes better than) massive, expensive systems from companies like Google and OpenAI, proving you don't need a giant brain if you have the right training.

3. Orchard-Claw: The "Personal Assistant" Agent

• The Job: Managing daily life tasks like sorting emails, checking calendars, and organizing files.
• The Challenge: These tasks happen in different "tools" (email apps, calendar apps). Usually, an AI trained on one tool gets confused when you switch to another.
• The Orchard Trick: They trained the AI using two different "control panels" (harnesses) at the same time. It's like teaching a driver to drive both a manual and an automatic car simultaneously. This forced the AI to learn the concept of driving, not just the specific pedals of one car.
• The Result: The AI became very flexible. When they switched it to a more advanced control panel at the end, it didn't break; it actually got better at the job, showing it had truly learned the skill, not just memorized the buttons.

---

Why This Matters: The "Thin Layer" Revolution

The paper argues that the biggest bottleneck in AI research isn't the "brain" (the model); it's the "legs" (the environment).

• Before: Researchers built a custom engine for every car. If you wanted to test a new engine, you had to build a whole new car.
• Now (Orchard): Orchard is a universal chassis. You can drop any engine (AI model) into it, and it runs.
  • It's Cheap: Because it runs on standard cloud technology, it costs about 10 times less than existing commercial services.
  • It's Fast: It can run thousands of practice sessions at the same time without crashing.
  • It's Reusable: Data collected for a coding robot can be reused to train a shopping robot.

The Bottom Line

The Orchard paper says: "Stop reinventing the wheel."

By creating a clean, open, and cheap "playground" that works for everyone, they showed that open-source AI can compete with the biggest tech giants. They proved that with the right infrastructure and smart training recipes (like learning from mistakes and training on multiple tools), small, open models can solve complex, real-world problems just as well as the massive, closed systems.

They released all their code, data, and recipes to the public, hoping to accelerate the entire field of AI research by making the "playground" available to everyone.

Technical Summary

Technical Summary: Orchard: An Open-Source Agentic Modeling Framework

Problem Statement

Agentic modeling aims to transform Large Language Models (LLMs) into autonomous agents capable of planning, reasoning, and interacting with external environments to solve complex tasks. Despite significant investment, open research in this domain faces critical bottlenecks:

1. Infrastructure Constraints: Generating training trajectories requires thousands of concurrent, isolated sandbox environments. Existing solutions are either proprietary (limiting reproducibility and cost control) or tightly coupled to specific training stacks, preventing the reuse of data and recipes across different agent harnesses or domains.
2. Training Gaps: High-performing agentic systems often rely on proprietary codebases or models. Open-source frameworks frequently focus on orchestration rather than improving the underlying agentic capabilities of LLMs through scalable, reproducible training.
3. Generalization Limitations: Agents trained on single-harness or single-domain data often fail to generalize to unseen tool interfaces, task distributions, or evaluation benchmarks.

Methodology: The Orchard Framework

The authors present Orchard, an open-source framework designed to decouple the environment layer from the agent training stack. The framework consists of a core infrastructure component and three instantiated training recipes.

1. Orchard Env: A Thin, Kubernetes-Native Environment Service

At the core of Orchard is Orchard Env, a standalone service designed to be reusable across task domains, agent harnesses, and pipeline stages (distillation, RL, evaluation).

• Architecture: It follows a three-layer design: a Python Client SDK, a FastAPI Orchestrator managing sandbox lifecycles in Kubernetes, and a lightweight In-Pod Agent injected into each sandbox container at runtime.
• Key Design Choices:
  • Agent Injection: Instead of baking agents into Docker images, Orchard Env injects an execution agent into user-provided images at runtime, supporting heterogeneous environments without per-image rebuilds.
  • Direct Routing: Execution and file requests are routed directly to the sandbox Pod IP, bypassing the Kubernetes API server and WebSocket overhead, achieving an average command execution latency of 0.28s.
  • Cost Efficiency: By leveraging standard Kubernetes primitives (including spot instances), Orchard Env reduces sandboxing costs by approximately 10x compared to managed alternatives like E2B or Daytona.
• Capabilities: It provides primitives for sandbox lifecycle management, command execution, file I/O, network policy, and REST API access, supporting diverse environments (code repos, web browsers, desktops).

2. Agentic Modeling Recipes

Built atop Orchard Env, the authors develop three training recipes (SFT + RL) across different domains:

A. Orchard-SWE (Software Engineering)

• Goal: Train agents to resolve GitHub issues.
• Data: Distilled 107K trajectories from frontier models (MiniMax-M2.5, Qwen3.5-397B) using both OpenHands and mini-swe-agent harnesses.
• Innovations:
  • Credit-Assignment SFT: Unlike prior work that discards failed trajectories, this method uses retrospective value estimation to identify "rise segments" (productive progress) in unresolved trajectories, converting them into supervised signals.
  • Balanced Adaptive Rollout (BAR): An online rollout-allocation method that adaptively assembles training groups with balanced positive/negative rewards to avoid wasted compute on easy/hard prompts and reduce noise in group-relative advantage estimators.
• Model: Qwen3-30B-A3B-Thinking (~3B active parameters).

B. Orchard-GUI (Browser Navigation)

• Goal: Train a vision-language agent for web navigation.
• Data: Curated from 15,601 seed tasks (PAE-WebVoyager, InSTA-v3) with teacher trajectories from Qwen3-VL-235B.
• Innovations:
  • Generic Harness: Uses a standard ReAct-style tool-calling interface rather than a bespoke browser harness to ensure generalization.
  • Data Efficiency: Trained on only 0.4K distilled trajectories for SFT and 2.2K open-ended tasks for RL, yet outperforms models trained on hundreds of thousands of tasks.
• Model: Qwen3-VL-4B-Thinking.

C. Orchard-Claw (Personal Assistant)

• Goal: Train agents for productivity workflows (email, calendar, tool use).
• Data: Synthesized 0.2K tasks from Claw-Eval and ClawHub, distilled from MiniMax-M2.5.
• Innovations:
  • Cross-Harness Training: Trained on both ReAct-style and ZeroClaw harnesses to study transferability.
  • End-to-End RL: Uses environment-grounded rewards to refine agent behavior beyond teacher distillation.
• Model: Qwen3-30B-A3B-Thinking.

Key Results

Orchard-SWE Performance

• Achieved 67.5% on SWE-bench Verified (SFT + RL), setting a new state-of-the-art (SOTA) among open-source models of comparable size (~3B active parameters).
• Outperforms dense 32B and 72B open-source baselines (e.g., OpenSWE-72B at 66.0%) and approaches frontier proprietary systems (MiniMax-M2.1 at 74.0%).
• Demonstrated superior cross-harness generalization: While other models collapsed when evaluated on unseen harnesses (e.g., dropping from 62.4% to 3.6%), Orchard-SWE maintained performance within a narrow band (45.0%–64.3%) across OpenHands, mini-swe-agent, and Kimi-CLI.

Orchard-GUI Performance

• Achieved an average success rate of 68.4% across WebVoyager, Online-Mind2Web, and DeepShop.
• Surpassed the strongest prior open-source models (MolmoWeb-8B at 51.9%) and even outperformed its own 235B teacher model on long-horizon benchmarks.
• Remained competitive with proprietary systems (Gemini CUA at 69.3%) despite using a 4B backbone and minimal training data.

Orchard-Claw Performance

• Achieved 59.6% pass@3 on Claw-Eval with SFT+RL, significantly outperforming same-size baselines.
• Showed a +14.3% improvement in pass@3 when paired with the advanced ZeroClaw harness at inference, demonstrating that training with the target harness improves the agent's ability to leverage advanced features (subagents, auto-compact).

Significance and Claims

The paper claims that the environment layer is the foundational substrate governing the reusability of agentic modeling artifacts. By providing a thin, open, and harness-agnostic environment service, Orchard enables:

1. Reusability: Trajectory data, SFT recipes, RL rollouts, and evaluation protocols can be transferred across domains (SWE, GUI, Assistant) and harnesses without rebuilding infrastructure.
2. Scalability & Cost: The framework makes large-scale agentic training affordable (10x cheaper than managed services) and reproducible for the open-source community.
3. Generalization: Decoupling the environment from the training stack allows models to learn harness-agnostic skills, leading to robust performance on unseen tools and tasks.

The authors release the full Orchard framework (environment service, training recipes, and datasets) to accelerate research in scalable agentic modeling, arguing that infrastructure design is as critical as algorithmic innovation for advancing open-source AI agents.