Orchard – Microsoft Research's Open-Source Agentic AI Modeling Framework

1. What is Orchard

Orchard is an open-source Agentic AI modeling framework introduced by Microsoft Research. At its core is the Kubernetes-based Orchard Env environment service, which enables cross-domain reuse of sandboxes for data distillation, reinforcement learning rollout, and evaluation. The framework has already covered three typical scenarios: software engineering, browser navigation, and personal assistants. It also opens up the training data and evaluation methods, providing a reproducible infrastructure for Agent research.

Image source: Official article
Image source: official article

Technical positioning and domain: Orchard belongs to the domain of Agentic AI modeling and training infrastructure, targeting research teams that require unified environments, standardized training pipelines, and reproducible evaluation. Unlike most frameworks that only provide inference or simple orchestration, Orchard integrates environment services, training recipes, data protocols, and evaluation benchmarks into a complete system, positioning itself as the "operating system layer" for Agent research.

Development background: Developed primarily by Microsoft Research, the team has deep expertise in Agent systems, reinforcement learning, and software engineering automation. The motivation for development stems from common issues in existing Agent frameworks, such as fragmented environments, mismatches between training and deployment environments, and non-open data, which hinder the reproducibility and portability of research results.

Core value: Orchard addresses three major pain points in Agent research: first, it unifies environments across domains, supporting a single infrastructure for code, web pages, and desktop tasks; second, it ensures consistency between training and deployment environments, eliminating mismatches by training directly within real Harness environments; third, it fully opens up data and evaluation, providing 107K SWE trajectories and 3,070 GUI multimodal rollout data, enabling reproducible research.

2. Key Features

• Cross-Domain Unified Environment Service (Orchard Env): A sandbox lifecycle management service built on Kubernetes, offering command execution, file I/O, network policy control, and REST API. A single infrastructure supports code execution, web rendering, desktop operations, and productivity workflows, avoiding the need to rebuild environments for each domain.

• Three Domain Training Recipes: Orchard-SWE focuses on code repair, Orchard-GUI handles visual web navigation, and Orchard-Claw targets daily productivity tasks such as email and calendar. Each recipe provides a complete SFT + RL training pipeline, allowing researchers to directly reuse or fine-tune based on it.

• Training within Real Harness Environments: Supports end-to-end training and evaluation directly in real deployment harnesses such as Codex, OpenClaw, and ZeroClaw. This design eliminates inconsistencies between training and deployment environments, making the model's performance in real-world scenarios more predictable.

• Open-Source Dataset and Evaluation Protocol: Releases 107K SWE trajectories and 3,070 GUI multimodal rollout data, along with corresponding evaluation benchmarks and reproducible recipes. Researchers can directly use these datasets to train or evaluate their own Agent models, without the need to collect data from scratch.

• Credit-Assignment SFT: In the software engineering domain, the system does not discard partially failed trajectories, but instead extracts supervisory signals from effective segments to maximize the amount of usable training data. This is especially suitable for handling numerous partially successful cases in code repair, improving data utilization efficiency.

• Balanced Adaptive Rollout + Dense Rewards: To address the challenge of sparse feedback in reinforcement learning, a balanced adaptive rollout strategy is used to capture rare success signals, while on-policy distillation and rule-based process reward models are introduced to provide dense guidance for intermediate steps, accelerating convergence.

• Value Model Re-ranking: A 4B parameter value model is trained using rollout trajectories from 20 historical experiments. During inference, it scores multiple candidate solutions and selects the best one. This method improved Orchard-SWE's performance on SWE-bench Verified from 69.7% to 73.0%, demonstrating the potential of small models combined with value-based re-ranking.

• Harness-Agnostic Agent Logging: A lightweight agent logs model calls made by the harness itself and reconstructs them into training samples. This allows any RL codebase to interface with any harness without modifying the environment image, significantly reducing the engineering cost of integrating new harnesses into the training pipeline.

3. How to Use

1. Environment Requirements: You need a machine that can access a Kubernetes cluster (recommended for quick deployment with Azure AKS; non-Azure clusters are also supported). It is advised to use Linux as the operating system. For local development, install Python 3.8+ and pip, and ensure that the network can pull Docker images.

2. Install SDK: Install the Python SDK for Orchard Env by running pip install -e "orchard_env[dev]". After installation, configure the environment variables SANDBOX_BASE_URL (pointing to the orchestrator endpoint) and SANDBOX_API_KEY (access key).

3. Quickly Call the Sandbox: Create a sandbox and execute commands using the SandboxClient context manager. It supports both synchronous and asynchronous modes, allowing for file read/write operations, git patch application, and PTY sessions. Example code:

   from orchard_env import SandboxClient
   with SandboxClient() as client:
       result = client.run_command("echo hello")
       print(result.stdout)
   

4. Deploy the Orchestrator: Using the four scripts provided by Azure AKS (provision, build, deploy, smoke-test), you can deploy a multi-replica orchestrator in approximately 20 minutes. If using a non-Azure cluster, you must manually configure the Kubernetes namespace, storage class, and network policies. Refer to the deploy/ directory in the GitHub repository for guidance.

5. Run Training Recipes: Navigate to the trainer/slime/ directory in the GitHub repository and select the configuration file for Orchard-SWE, Orchard-GUI, or Orchard-Claw based on your needs. Execute python run.py --config config_swe.yaml to start the complete SFT + RL training process. During training, the system will automatically invoke Orchard Env to create sandboxes for rollout and evaluation.

6. Notes: When training large-scale agents, it is recommended to use Spot instances to reduce costs; Orchard Env by default uses Redis distributed locks to coordinate sandboxes, so Redis service must be deployed in advance; datasets for different domains need to be downloaded separately from HuggingFace and placed in the specified path.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendations: For research teams that need to train Agent models from scratch and aim to validate across multiple domains such as code, web, and productivity, Orchard is the most comprehensive choice, with its built-in training pipeline and open-sourced data significantly reducing the initial cost. If the team primarily focuses on code fixing in the software engineering domain and values community activity and quick onboarding, OpenHands is a mature option, though it requires the team to independently resolve training environment issues. For application developers looking to quickly build a multi-Agent collaboration system, CrewAI's orchestration capabilities are more direct, but it lacks training and unified environment support. Orchard is suitable for organizations with Kubernetes operations capabilities that prioritize long-term reproducibility and cost control. If only short-term prototype validation is needed, AutoGPT or CrewAI paired with commercial APIs may be more convenient.

6. Editor's Summary

Orchard has made several substantive innovations in the field of Agentic AI modeling. First, it unifies sandbox services across multiple domains—such as code, web, and desktop—through a Kubernetes-native environment layer, addressing the long-standing issue of "environment fragmentation" and eliminating the need for researchers to reinvent the wheel for each task. Second, training mechanisms such as Credit-Assignment SFT and Balanced Adaptive Rollout provide engineering solutions for data utilization efficiency and sparse reward handling. Particularly, the approach of using a small model to achieve large model performance through value model re-ranking offers a viable path for research teams with limited resources. Third, Orchard opens source all training data, evaluation protocols, and training recipes, which is relatively rare in the Agent domain, directly enhancing the reproducibility of research.

In terms of practical value, Orchard offers significant cost advantages: self-hosted sandbox costs are approximately 10%–50% of commercial services. Combined with the reduced inference costs brought by small models, large-scale Agent training no longer relies on expensive commercial APIs. The primary users are Agent research teams with Kubernetes operations capabilities, enterprise labs aiming to build their own Agent training platforms, and academic institutions seeking to reproduce cutting-edge results at a low cost. For individual developers or startup teams, the deployment and learning curve may be relatively high, but once set up, the efficiency of subsequent iterations will significantly improve.

In terms of future development potential, Orchard's Harness-Agnostic design makes it easy to integrate with new task scenarios. If the community can accumulate more training recipes and data across various domains around this framework, Orchard has the potential to become the standard infrastructure for Agent research. Continued investment from Microsoft Research and the gradual growth of the open-source community will be key to its ecosystem development. Overall, Orchard is not "just another new framework," but rather a systematic reengineering of the infrastructure for Agent research. Its value will become even more evident as more teams adopt and contribute to it.

7. Application Scenarios

• Automated Software Engineering: Autonomous diagnosis of bugs, writing tests, generating patches, and validating them within real codebases. Orchard-SWE can be directly trained within harnesses like Codex, making it suitable for open-source project maintenance, enterprise internal code reviews, and automated repair pipelines in continuous integration.

• Intelligent Web Navigation: Automatically operate browsers to complete open-domain tasks such as ticket booking, shopping, and information retrieval based on visual understanding. Orchard-GUI achieves 68.4% on three major web benchmarks with 4B parameters, serving as an alternative to RPA in business scenarios requiring cross-site data collection or automated form filling.

• Personal Productivity Assistant: Execute complex workflows across tools such as email, calendars, and documents, such as automatically scheduling meetings, organizing inboxes, and generating reports. Orchard-Claw improves pass@3 from 59.6% to 73.9% under ZeroClaw, making it ideal for enterprise office automation.

• Agent Research Infrastructure: Provide a reproducible, low-cost training and evaluation platform for Agent research in both academic and industrial teams. Researchers can directly use open-source data and recipes for comparative experiments, or develop new Agent algorithms based on the Orchard Env, accelerating the construction of an open-source Agentic AI ecosystem.

8. FAQ

Q: What is the core difference between Orchard and OpenHands?
A: Orchard is a cross-domain modeling framework that provides a unified environment service, training pipeline, and open-source data, covering three major areas: code, web pages, and productivity. OpenHands primarily focuses on software engineering code repair, emphasizing reasoning and execution, with training capabilities requiring self-setup. Orchard is more suitable for research teams that need a complete training and evaluation system.

Q: What hardware and software environment is required to deploy Orchard?
A: A Kubernetes cluster is required (recommended Azure AKS, also supports non-Azure clusters), along with Python 3.8+. For training, it is recommended to use NVIDIA A100 or higher configuration GPUs, but Orchard's value model and inference can run on consumer-grade GPUs. The sandbox environment is automatically allocated by the cluster and does not require separate management.

Q: Does Orchard support Kubernetes clusters other than Azure?
A: Yes, but the official automation scripts are primarily designed for Azure AKS. For non-Azure clusters, you need to manually configure Kubernetes namespaces, storage classes, network policies, and Redis distributed locks. Refer to the YAML files in the deploy/ directory for adaptation.

Q: How can I obtain Orchard's open-source training data and model weights?
A: The training data (SWE trajectories, GUI rollouts, etc.) is hosted under the HuggingFace dataset microsoft/Orchard. The model weights are not directly published yet, but you can train them yourself by running the training recipes. Microsoft Research may release pre-trained models in the future; please keep an eye on updates to the GitHub repository.

Q: Can small models (3B–4B) really achieve the performance of large models (70B+)?
A: Yes, on specific benchmarks. Orchard-SWE achieves 73.0% on SWE-bench Verified, approaching the performance of state-of-the-art models like GPT-4. This is due to Credit-Assignment SFT more efficiently utilizing training data, Balanced Adaptive Rollout addressing sparse reward issues, and value model re-ranking optimizing inference selection. However, on more open-ended or knowledge-intensive tasks, small models may still be limited by their parameter count.

Q: Can Orchard's training recipes be used for agents in other domains?
A: Yes, but with adaptation. Orchard's training pipeline is Harness-Agnostic, meaning theoretically, you only need to implement a new harness and register it with the system to reuse the SFT + RL process. Currently, the official repository provides recipes for three domains: SWE, GUI, and Claw, as references.

9. Project Links

• Project Website (Microsoft Blog): https://www.microsoft.com/en-us/research/blog/orchard-an-open-framework-for-scalable-agentic-ai/
• GitHub Repository: https://github.com/microsoft/Orchard
• HuggingFace Dataset: https://huggingface.co/datasets/microsoft/Orchard
• arXiv Technical Paper: https://arxiv.org/pdf/2605.15040