InternLM/InternBootcamp

Official implement on InternBootCamp

InternAgentHarness (InternBootcamp) – What It Is

InternAgentHarness (also called InternBootcamp) is a research‑oriented framework for building, training, and evaluating large‑language‑model (LLM) agents. It provides a synthetic, programmable environment where an LLM can interact with external tools, receive state feedback, and be rewarded for its actions. The goal is not just to get a high benchmark score, but to create a closed‑loop pipeline that:

  1. Generates executable tasks (e.g., battery design, robot trajectory planning, financial prediction, poker decision‑making).
  2. Exposes verified tools that the model can call repeatedly (multi‑round tool calls).
  3. Manages the multi‑turn dialogue between the model and the environment.
  4. Computes rewards from intermediate steps and final outcomes, enabling reinforcement‑learning or supervised fine‑tuning.
  5. Records full interaction traces for reproducibility, data‑generation, and further training.

Core Concepts

Component Role
InstructionGenerator Creates the task prompt and the underlying “identity” data that defines the problem (e.g., the arithmetic expression to solve).
ToolManager Registers and runs external tools (functions, simulators, APIs) that the LLM can invoke.
InteractionManager Handles the back‑and‑forth between the model and the environment, allowing multiple rounds of tool calls and optional human‑style feedback.
RewardCalculator Scores each step and the final answer against ground‑truth or rule‑based criteria, producing a scalar reward for training.
Evaluator Runs a batch of episodes, collects trajectories, and outputs metrics for research experiments.

How It Works (High‑Level Flow)

  1. Prompt Design – The InstructionGenerator builds a natural‑language prompt describing the task.
  2. Model Rollout – The LLM receives the prompt and decides whether to call a tool.
  3. Tool Call – The ToolManager executes the requested tool (e.g., a physics simulator, a calculator, a database query) and returns the result.
  4. Environment Feedback – The InteractionManager may add follow‑up questions or hints based on the tool output.
  5. Reward Calculation – After each step and at the end, the RewardCalculator compares the model’s answer to the ground truth and emits a reward signal.
  6. Loop – Steps 2‑5 repeat until a termination condition is met (max turns, perfect score, etc.).
  7. Logging – Every turn (model message, tool request, tool response, reward) is saved to a JSONL file for later analysis or fine‑tuning.

What You Can Do With It

  • Create new synthetic tasks by implementing a tiny subclass of BaseInstructionGenerator and optionally a BaseTool and BaseInteraction.
  • Collect training data: run the framework in “rollout” mode to generate thousands of multi‑turn interaction logs that can be used for supervised fine‑tuning or RLHF.
  • Benchmark tool‑use ability: evaluate how well a model plans, calls tools, and corrects itself across diverse domains (engineering, finance, games, robotics).
  • Run distributed tool servers: the built‑in Master‑Worker tool server lets you scale heavy tools across multiple machines.

Getting Started (From the README)

  1. Install the repository and its sub‑modules (verl, openevolve) with pip install -e . and the provided requirements‑editable.txt.
  2. Define a task by writing an InstructionGenerator subclass and a YAML config that sets generation ratios, random seeds, and data splits.
  3. Optionally add tools (e.g., a calculator) by subclassing BaseTool and providing a JSON schema that will be sent to the LLM as a function definition.
  4. Run data generation with the internbootcamp.utils.data_generation CLI, which outputs JSONL (and optional Parquet) files containing full episode traces.
  5. Evaluate a model with internbootcamp.utils.run_evaluation, pointing it at your dataset, API key, and the tool/interaction configs.

Who It’s For

Researchers and developers who need a flexible sandbox for LLM‑agent experiments—especially those working on tool‑augmented reasoning, reinforcement learning from human feedback, or multi‑step planning in simulated environments.

All details above are taken directly from the project's README; no additional features have been inferred.

Related

  • Project
    rllm-org/rllm

    An open-source framework for training language agents with reinforcement learning, allowing the same agent code to be used across different backends, sandboxes, and benchmarks.

  • Project
    langwatch/scenario

    An agent testing framework that uses simulations, user simulators, and judge agents to evaluate the behavior and robustness of AI agents in multi-turn conversations.

  • Project
    verl-project/uni-agent

    Uni‑Agent is an open‑source framework for plugging any LLM‑based agent harness into a scalable, sandboxed pipeline that can run thousands of long‑horizon sessions in parallel, collect traceable trajectories, and train agents via reinforcement learning. It offers modular abstractions, reproducible example recipes, and supports serverless back‑ends like veFaaS and Modal.

  • Project
    camel-ai/loong

    A framework for scaling reasoning-capable models through a self-improvement loop of synthetic data generation and automated verification.

  • Project
    Accio-Lab/Dressage

    A scalable reinforcement learning framework for LLM agents that enables training across diverse agent types and sandboxes with token-level trajectory recording.