AllenAct: an AI2 framework for Embodied AI research in PyTorch

What AllenAct is for, and who it is aimed at

AllenAct is a learning framework for Embodied AI research, built and backed by the Allen Institute for AI. The README frames the design goal directly: it is "a modular and flexible learning framework designed with a focus on the unique requirements of Embodied-AI research." The intended user is a researcher who trains agents that perceive and act inside a simulated 3D or grid environment, not someone fitting a classifier to a static dataset.

The problem it addresses is recombination cost. In embodied research, a lab typically has an environment (iTHOR, RoboTHOR, Habitat, MiniGrid), a task (PointNav, ObjectNav), and an algorithm (PPO, DD-PPO, A2C, DAgger, offline imitation). Wiring those three together is where most of the engineering time goes, and each new combination tempts a rewrite. AllenAct's stated approach is to decouple tasks from environments so that, in the README's words, researchers can "easily implement a large variety of tasks in the same environment." If your work involves comparing an algorithm across several environments, or several tasks inside one environment, that decoupling is the reason to look at the project.

How the framework is put together

The repository layout shows the split between core and integrations. The allenact/ directory holds the framework itself, allenact_plugins/ holds the environment integrations, projects/ holds start-up code, and pretrained_model_ckpts/ holds released checkpoints. The top level also carries main.py, a training entry point, and conda/ for environment files.

The README lists the supported environments: iTHOR, RoboTHOR and Habitat as embodied 3D simulators, plus grid-worlds including MiniGrid, with OpenAI Gym also listed in the support table. On the algorithm side it names on-policy methods (PPO, DD-PPO, A2C), imitation learning including DAgger, and offline training such as offline IL. Two features stand out as design choices rather than feature-list padding. Sequential algorithms let you compose a sequence of training routines, which the README describes as often the key to successful policies. Simultaneous losses let you combine objectives, for example an external self-supervised loss alongside a PPO loss. Both point at the same architecture: a training routine is a composable object, not a fixed loop.

The framework targets PyTorch, which the README calls out as unusual: "One of the few RL frameworks to target PyTorch." Action spaces can be discrete or continuous. Visualization of first and third person views and intermediate model tensors is wired into Tensorboard.

The dependency file is where the age shows. requirements.txt pins gym==0.17.3, numpy==1.19.5, protobuf==3.14.0, tensorboardX==2.1 and torch>=1.6.0,!=1.8.0,<2.0.0. The torch constraint excludes 1.8.0 and stops short of 2.0. Those are hard bounds, and they are the first thing to reconcile with your own environment.

Installing AllenAct and running a first training job

The README points installation at the project's own documentation rather than reproducing steps inline: the Install link goes to https://www.allenact.org/installation/installation-allenact/. That page is the authoritative source, and it is where the Python version and simulator prerequisites are stated. The README badge indicates Python 3.6+.

There is a conda/ directory in the repository, which is where the project keeps its environment definitions. If you prefer to install into your own environment, the repository's requirements file is the dependency list. Install it from the repository root:

pip install -r requirements.txt

Because the file pins old versions of gym, numpy and protobuf, run this in a fresh virtual environment or conda env rather than alongside an existing project. The torch line allows 1.6.0 and above but excludes 1.8.0 and anything from 2.0.0 onward, so a current PyTorch install will not satisfy it.

For a first real job, the repository ships start-up code under projects/ and pretrained checkpoints under pretrained_model_ckpts/. The training entry point is main.py at the repository root. The documentation's tutorial section at https://www.allenact.org/tutorials/ is where the concrete invocation for a given experiment config is given; the README does not reproduce the command, so take the arguments from the tutorial rather than guessing at flags. What you should expect to see on a successful run is progress output plus Tensorboard events, since the README states that first and third person views and intermediate model tensors are visualized through Tensorboard.

Where AllenAct gets in your way

The most concrete limitation is version drift. The released versions are v0.5.2 from 2022-08-16, v0.5.0 from 2022-03-24, and v0.4.0 from 2021-06-15. The last push to the repository was on 2026-05-19, so the codebase has moved since the last tagged release, but the release cadence itself has been slow for years. If your project needs a maintained release line with a changelog you can pin against, that is a real friction point.

The pinned dependencies compound it. torch is capped below 2.0.0, gym is pinned to 0.17.3, and protobuf to 3.14.0. Any of these can collide with a modern stack, and resolving the collision means either isolating AllenAct in its own environment or updating pins yourself, which puts you off the tested configuration.

Simulator setup is the second cost, and the README does not hide it. iTHOR, RoboTHOR and Habitat are external simulators; Habitat in particular is a separate project with its own build requirements. The AllenAct repository does not document their installation beyond linking to them, so the practical difficulty of getting a first run depends on which simulator you pick. MiniGrid and Gym environments are far lighter than the 3D simulators, which makes them the sane choice for a first smoke test.

Finally, this is a research framework, not a deployment path. Nothing in the README describes serving a trained policy, exporting to a runtime, or running on a robot. If your end goal is an embedded agent, AllenAct covers the training half only.

How it compares with habitat-lab and other RL stacks

The README names two projects it builds on: Ilya Kostrikov's pytorch-a2c-ppo-acktr library, and FAIR's habitat-lab, from which it borrows some data structures. That second relationship is the useful comparison. Habitat-lab is Meta's platform for embodied AI, and it is itself a supported environment inside AllenAct. The difference in approach is scope: habitat-lab couples a simulator and training stack around the Habitat simulator, while AllenAct treats the simulator as one of several pluggable backends alongside iTHOR, RoboTHOR and MiniGrid. If you intend to work only in Habitat and want to stay close to that project's own tooling, habitat-lab is the more direct route. If you want to move the same task definition between iTHOR and Habitat, AllenAct's environment and task decoupling is the reason to accept its extra layer.

Against general-purpose RL libraries, the distinction is the environment model. A standard RL library assumes a Gym-style step API and a vectorized batch of independent environments. Embodied tasks bring large visual observations, long episodes, and evaluation protocols that are specific to navigation. AllenAct's simultaneous-loss and sequential-algorithm features exist because of that setting. A general library can be made to do this, but you write the glue yourself.

Maintenance, releases and what the licence actually says

The repository is not archived, and the last push was on 2026-05-19. That is recent activity, but the tagged releases tell a different story: the newest is v0.5.2 from 2022-08-16. Treat the maintenance picture as code that still receives commits with a release line that has been quiet. Before adopting, check whether the fix or feature you need landed after v0.5.2 and is only available from main.

Upgrade cost is dominated by the dependency pins rather than by API churn. Because requirements.txt holds torch below 2.0.0 and gym at 0.17.3, an upgrade path means revisiting those constraints and re-testing the environments you use. Budget for that as a project of its own, not a version bump.

The licence badge in the README says MIT, and the README states that AllenAct is MIT licensed as found in the LICENSE file. The repository metadata reports the licence as NOASSERTION, which means an automated classifier could not confirm the file's contents against a standard template. Those two signals disagree, and the LICENSE file is the one that governs. Read it before you depend on the project in anything you distribute. This is a description of what the files say, not legal advice. The README also asks that you cite the AllenAct paper (arXiv:2008.12760) if you use the work.

Editorial conclusion

AllenAct fits a research group that wants to run PointNav or ObjectNav in iTHOR, RoboTHOR or Habitat and then recombine those tasks with PPO, DD-PPO, A2C or DAgger without rebuilding the training loop. It does not fit a team that needs a current, frequently released dependency stack, or one that only wants supervised computer vision. Before committing, verify a clean install of requirements.txt on your Python version, confirm the simulator you intend to use builds on your hardware, and check that the pretrained_model_ckpts directory holds a checkpoint for your task.

Frequently asked questions

Official sources

1. allenai/allenact on GitHub
2. Issues
3. Project website
4. README
5. Releases