# Marco-o1 v3 compresses the model instead of lengthening the chain > Marco-o1 is an open reasoning model from Alibaba International Digital Commerce whose interesting work is in the training recipes rather than the weights: v2 added DPO on self-built data, v3 trains a pluggable Linear module to compress context and adds test-time training, and EDPO adds an online difficulty selector for reinforcement learning. Useful as a research base, weak as a turnkey deployment, since the README documents no hardware requirements and no releases. **ATH-MaaS/Marco-o1** — An Open Large Reasoning Model for Real-World Solutions - Repository: https://github.com/ATH-MaaS/Marco-o1 - Stars: 1,538 · Forks: 82 - Language: Python - License: NOASSERTION - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/ath-maas-marco-o1 ## Open-ended questions are the actual target Most open reasoning work concentrates on subjects with verifiable answers, where reinforcement learning gets a clean reward signal: mathematics, physics, coding. The README says Marco-o1 does not limit itself to those, and emphasises open-ended solutions, with the stated goal of a general model for agentic use that incorporates comprehensive planning and function call ability. That framing matters for what you can expect. A reward model that checks a final answer gives a clean training signal. A planning task judged on several plausible good answers does not, and the project acknowledges the difference by treating the open-ended case as the research problem rather than as an extension. There is also a stated lineage: the README says the work is inspired by OpenAI's o1, from which the name derives, and describes itself as an exploration of an unclear technical roadmap for large reasoning models. The project is from the MarcoPolo Team at Alibaba International Digital Commerce, and the model, data, paper and demo are all published through the AIDC-AI organisation. ## Three versions, each changing the training recipe The release history in the README is the most useful part of the page, because each entry describes a mechanism rather than a score. v1 came out on 2024-11-13 as the baseline, aimed at open-ended solutions across domains. v2 followed on 2025-02-14, built entirely on self-built data and passed through DPO, with the stated focus on mathematical problem solving, planning and instruction following. The paper for v2, on widening the distillation bottleneck for reasoning models, was accepted at ACL 2025. v3, dated 2025-02-09 in the news list, is the one with the interesting engineering. A pluggable Linear component called MAM, the Mixed Attention Module, is trained on top of an existing dense model and used to compress the model dynamically in order to save context tokens. Alongside it they introduce TTT, Test-Time Training. The claimed result is a 20% reduction in inference cost with an average performance improvement of 4.7%. EDPO, also 2025-02-09, is a training-time idea rather than a model: Difficulty-Estimated Policy Optimization, built on an online data difficulty selector, which the authors describe as the first work they know of on online data selection. The claimed effect is resistance to the noise that zero advantage brings into GRPO, an average 2.4% improvement, and multi-scale routing by prompt difficulty for large-scale online services. The A State-Transition Framework for Efficient LLM Reasoning paper was accepted at ICLR 2026. The repository lists code directories for v3 and EDPO: `src/v3/src` and `src/DEPO/src`. Every number above is the project's own report in the README, with no evaluation protocol described. ## Cloning and installing the requirements Installation is three commands, and the dependency file is short enough to read in full: ```bash git clone https://github.com/AIDC-AI/Marco-o1 cd Marco-o1 pip install -r requirements.txt ``` The requirements file lists four packages: `torch`, `transformers`, `vllm==0.6.2` and `tqdm`. That single pin is the most consequential line in the file. vLLM 0.6.2 is a specific release, and an exact pin like this does not move, so a fresh environment on a newer CUDA or Python setup may not resolve cleanly. Anyone picking this up should expect to adjust the pin deliberately rather than to let a resolver do it. Nothing else is documented. There is no GPU requirement, no minimum VRAM, no quantisation path and no Docker image in the README. The repository root holds `LICENSE`, `NOTICE`, `README.md`, `assets/`, `data/`, `requirements.txt` and `src/`, so there is no packaging, no config system and no inference server in the box. ## Two ways to run it, and a FastAPI example The usage section describes loading the chain-of-thought model with the standard Hugging Face classes: ```python from transformers import AutoTokenizer, AutoModelForCausalLM tokenizer = AutoTokenizer.from_pretrained("AIDC-AI/Marco-o1") model = AutoModelForCausalLM.from_pretrained("AIDC-AI/Marco-o1") ``` Then there are two inference scripts rather than a single entry point: ```bash ./src/output/talk_with_model.py ./src/output/talk_with_model_vllm.py ``` The first uses plain transformers, the second the vLLM path. The README says you can put your own inputs inside them, which means the scripts are examples to edit rather than a CLI with arguments. For serving, the README points at the README.md inside the `examples` folder for a FastAPI deployment rather than documenting the routes here. That is a documentation gap rather than a missing feature, but it means the serving story is something you have to read in a second file. One item on the roadmap is worth flagging: the news list marks Marco-o1 Agentic as Coming Soon, described as a more powerful agentic model. The function-calling and planning ambition in the project description is therefore partly aspirational today. ## Three inconsistencies you will notice immediately This is a research repository with rough edges, and three of them are visible from the first screen. First, identity. This repository is ATH-MaaS/Marco-o1, while every clone command, model identifier and Hugging Face path in the README names AIDC-AI. The organisation changed hands at some point and the README was not fully updated, so the difference between this tree and the upstream one may be more than a rename. Second, the badge in the README says Version 2.0.0, while the news section describes a released v3 and points at `./src/v3` for its code. Which artefact you get by following the README is therefore ambiguous. Third, licensing. The badge claims Apache 2.0, and the root contains both `LICENSE` and `NOTICE`, but GitHub classifies the repository license as one it cannot identify. For a model release where weight licensing and code licensing can differ, read both files before you build on it. Project status is also worth stating plainly. There are no GitHub releases, so there is no tag to pin, and the last push was on 2026-06-17. The research output continues through papers rather than through versioned artifacts. The alternative is straightforward: a hosted reasoning API gives you a maintained serving stack, documented hardware and a stable version, and costs money per token while keeping your prompts on someone else's infrastructure. Self-hosting Marco-o1 gives you the weights, the v3 compression recipe and the EDPO training code, and costs you a GPU, a pinned vLLM and the work of maintaining it. For reproducing the research the second option is the only one; for a product deadline the first is usually cheaper. ## Conclusion Adopt Marco-o1 if you are doing research on reasoning distillation or reinforcement learning and want to reproduce a published recipe, starting with `pip install -r requirements.txt` and the scripts under `src/`. Do not adopt it as a production inference stack, because requirements.txt pins `vllm==0.6.2`, the README documents no GPU or memory requirement, and there are no GitHub releases to pin against. Verify first that the LICENSE file matches the Apache 2.0 badge, that the weights you pull are the ones the README points at, since this repository is ATH-MaaS/Marco-o1 while every model link names AIDC-AI, and that the last push, 2026-06-17, predates any work you plan to build on. ## FAQ ### How do I install Marco-o1? Clone the repository, change into the Marco-o1 directory and run `pip install -r requirements.txt`. The requirements file lists torch, transformers, vllm==0.6.2 and tqdm. ### What is the difference between Marco-o1 v2 and v3? v2 was released in February 2025, built entirely on self-built data and trained with DPO. v3 trains a pluggable Linear module called MAM on the existing dense model to dynamically compress it and save context tokens, and adds test-time training, with a claimed 20% inference cost reduction and 4.7% average improvement. ### What is EDPO in Marco-o1? EDPO stands for Difficulty-Estimated Policy Optimization and is a training algorithm built on an online data difficulty selector. The README claims it resists the noise that zero advantage introduces into GRPO, with an average 2.4% improvement, and can route by prompt difficulty in large-scale online services. ### Can I run Marco-o1 with vLLM? Yes. The repository ships a vLLM inference script alongside the plain transformers one, and requirements.txt pins vllm==0.6.2, so the exact version is fixed rather than a minimum. ### Where can I download the Marco-o1 model weights? Through the Hugging Face organisation AIDC-AI, using the identifier AIDC-AI/Marco-o1 in the transformers loading example. Note that this repository is under ATH-MaaS while the README's links all point at AIDC-AI. ## Sources - [ATH-MaaS/Marco-o1 on GitHub](https://github.com/ATH-MaaS/Marco-o1) - [Issues](https://github.com/ATH-MaaS/Marco-o1/issues) - [README](https://github.com/ATH-MaaS/Marco-o1/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ath-maas-marco-o1