The dataset viewer is not available because its heuristics could not detect any supported data files. You can try uploading some data files, or configuring the data files location manually.

AgentForge-Bench

AgentForge-Bench is a benchmark suite for evaluating autonomous AI agents on realistic, multi-step terminal environments.

The benchmark focuses on capabilities that become increasingly difficult as the interaction horizon grows: planning, state tracking, dependency reasoning, recovery, temporal consistency, history preservation, error handling, and reliable execution.

The central benchmark principle is:

Correct final state is necessary, but correct trajectory is part of correctness.

An agent should not receive full credit merely because it eventually reaches a desired state. The trajectory used to reach that state must also remain valid, consistent, and recoverable.

Benchmark Goals

AgentForge-Bench is designed to evaluate whether an agent can:

Plan across multiple dependent steps
Maintain state over long interaction horizons
Understand state-machine transitions
Preserve checkpoints and historical context
Recover from failures and disturbances
Handle invalid or repeated actions safely
Maintain temporal consistency
Resist stale or conflicting state
Preserve branch-specific context
Re-converge correctly after divergence
Operate reliably under trajectory-level pressure
Complete tasks through verifiable execution rather than shortcut behavior

Task Suite

AgentForge-Bench V1 currently contains three benchmark tasks.

1. Long-Horizon Kubernetes Recovery V1

A stateful Kubernetes-style recovery environment designed around a long multi-phase operational trajectory.

The task evaluates:

State tracking
Dependency-aware planning
Configuration management
Validation ordering
Checkpoint preservation
Deployment lifecycle reasoning
Failure and degradation handling
Recovery semantics
History preservation
Temporal consistency
Repeated disturbance resistance
Branch divergence and re-convergence
Stale-context protection
Invalid-action resistance
Long-horizon trajectory reproducibility

The canonical recovery trajectory contains multiple dependent phases including inspection, configuration, validation, checkpointing, startup, monitoring, degradation, restoration, recovery, verification, and finalization.

Interface support:

Gymnasium
OpenEnv

2. Long-Horizon Stateful System V1

A stateful long-horizon environment focused on maintaining consistency across dependent actions and evolving system state.

The task is designed to test whether an agent can reason about:

Persistent state
Sequential dependencies
State transitions
Recovery behavior
Multi-step execution
History-sensitive decisions
Correct completion conditions

The task emphasizes trajectory correctness rather than isolated action correctness.

3. Terminal File Repair V7

A multi-file terminal repair task requiring an agent to inspect, understand, and repair a Python application with dependent configuration and service components.

The task evaluates:

Repository inspection
Multi-file reasoning
Dependency resolution
Configuration consistency
Service interaction
Debugging
Repair planning
Verification
End-to-end correctness

The task is designed so that local fixes must remain consistent with the broader application state.

What Makes AgentForge-Bench Different?

Many agent evaluations focus primarily on whether an agent can produce a correct final answer or modify a small number of files successfully.

AgentForge-Bench instead emphasizes the trajectory.

An agent may need to:

Inspect the environment
Infer the current state
Select a valid action
Satisfy prerequisites
Preserve previously established state
Create or restore checkpoints
React to disturbances
Avoid invalid shortcuts
Maintain historical context
Complete the final state through a valid sequence

This creates pressure on long-horizon reasoning and execution reliability.

Long-Horizon Evaluation

The benchmark includes trajectory-level challenges such as:

History Accumulation

The agent must preserve information generated many steps earlier.

Checkpoint Preservation

Checkpoint state must remain distinct from the current timeline and must not be silently overwritten by later actions.

Temporal Consistency

Older state, current state, and restored state must remain semantically separated.

Branch Divergence

Different execution branches can temporarily diverge while preserving branch-specific context.

Delayed Re-convergence

A valid recovery path may require the agent to return to a shared trajectory after several intermediate transitions.

Disturbance Recovery

Repeated disturbances and invalid actions can occur before successful completion.

Stale Context Protection

Outdated state must not incorrectly replace newer or authoritative state.

Repetition Pressure

Repeated valid or invalid actions must not provide an unintended shortcut to completion.

Evaluation Philosophy

AgentForge-Bench is intended to distinguish between:

Action-level correctness
State-level correctness
Trajectory-level correctness
Recovery correctness
Temporal consistency
Final outcome correctness

A robust agent should satisfy all relevant constraints rather than optimize only for the final observable state.

Environment Interfaces

AgentForge-Bench tasks can expose standardized agent-environment interfaces.

Current V1 environments include support for:

Gymnasium
OpenEnv

These interfaces make the environments easier to integrate with agent evaluation and reinforcement-learning workflows.

Verification

Tasks are accompanied by verification infrastructure intended to validate both the environment behavior and the benchmark contract.

The project uses components such as:

Oracle validation
Verifier tests
Environment tests
Gymnasium contract tests
OpenEnv contract tests
Full regression tests
Python syntax checks

The goal is to ensure that benchmark behavior is deterministic, reproducible, and testable.

Repository Structure

The benchmark repository contains the following V1 tasks:

long-horizon-kubernetes-recovery-v1/
long-horizon-stateful-system-v1/
terminal-file-repair-v7/

Each task is maintained as an independent benchmark environment with its own task configuration, instructions, environment implementation, verification logic, and supporting artifacts.

Research Direction

AgentForge-Bench is intended as a foundation for studying reliable autonomous agents under increasingly long interaction horizons.

Future benchmark extensions can investigate:

Deeper trajectory horizons
More complex state dependencies
Multi-branch execution
Adversarial state transitions
Delayed failures
Persistent environment changes
Cross-phase memory pressure
Multi-agent coordination
More difficult terminal environments
Long-horizon reinforcement learning

Version

AgentForge-Bench V1

Current task suite:

3 tasks

The benchmark is under active development.

Author

Mohamed Ahmed

Email: engmohamedelshrbeny@gmail.com