Denario walks a research project from idea to LaTeX paper

A pipeline of agent stages rather than a single assistant

Denario is described as a multiagent system designed to be a scientific research assistant, and its structure is a pipeline of stages you drive one at a time. The unit of work is a Denario instance bound to a project directory, and the stages run in order: describe the data, get an idea, get the method, get the results, get the paper.

The implementation is a stack of existing frameworks rather than something built from scratch. Denario implements its agents with AG2 and LangGraph, and uses cmbagent as the research analysis backend. The project documentation also states that Denario and Cmbagent are open source software projects under GPL-3 and Apache 2 licences respectively, and that no private or public organisations or individuals other than the three copyright holders can claim IP or ownership on these packages. The three authors are Pablo Villanueva-Domingo, Francisco Villaescusa-Navarro and Boris Bolliet.

That framing is useful for setting expectations. Denario is a research artefact with a paper behind it, published in PRX Intelligence on October 1, 2026, and version 1.0 was released on November 3, 2025. The claims being made are about the pipeline working end to end, not about any stage being individually better than a human doing that step.

The five calls that make up a full run

The API is short enough to read in one sitting, which is unusual for a multiagent framework. You initialise the instance and hand it a project directory:

from denario import Denario

den = Denario(project_dir="project_dir")

Then you describe the data and the tools to be employed with set_data_description. The documentation example is a prompt about experimental data in data.csv analysed with sklearn and pandas, describing time-series measurements from a particle detector.

From there the stages are one call each. den.get_idea() generates a research idea from that data specification, den.get_method() produces the methodology for working on the idea, and den.get_results() performs the required computations and produces the plots and results. Finally den.get_paper(journal=Journal.APS) writes the LaTeX article, and the Journal enum carries the APS (Physical Review Journals) style among others.

The important design point is that each stage is optional and overridable. The documentation states you can manually provide any info as a string or markdown file in an intermediate step, using the set_idea, set_method or set_results methods. So you can let the system draft the methodology, replace it with your own file, and still let it compute the results and write the paper. That is the difference between a pipeline you can steer and a black box.

Installing it, and the credentials you cannot avoid

The recommended install is a virtual environment plus pip, and the documentation recommends Python 3.12:

python -m venv Denario_env
source Denario_env/bin/activate
pip install "denario[app]"

There is a uv path as well, which creates a project and adds the package:

uv init
uv add denario[app]

The app extra pulls in denario_app, which is the GUI, and the GUI is then launched with:

denario run

The dependency list explains a lot about how the system works. It pulls langchain-google-genai, langchain-anthropic, langchain-openai and langgraph, plus google-cloud-aiplatform and google-ai-generativelanguage, so the agents talk to hosted models rather than running anything locally. cmbagent is a direct dependency at version 0.0.1post63, and futurehouse-client is present, which is the piece that lets the backend query scientific databases. filelock is there to coordinate concurrent file access, and pymupdf plus pillow handle document and image work.

On credentials the documentation is blunt: Denario makes use of LLMs from OpenAI, Claude and Gemini, and points to its own documentation page on LLM API keys for setup. There is no offline mode described anywhere in the repository, so budget for API usage before you budget for compute.

Docker brings LaTeX with it, on port 8501

The container route exists because the final stage produces a LaTeX article, and LaTeX is a heavy dependency to install on a laptop. The documentation says the Docker image includes all the required dependencies for Denario including LaTeX.

The published image is pulled from Docker Hub:

docker pull pablovd/denario:latest

and run with the GUI port mapped:

docker run -p 8501:8501 --rm pablovd/denario:latest

An interactive shell inside the container is available too:

docker run --rm -it pablovd/denario:latest bash

Volumes are how you feed data in and read output back. The documentation gives the pattern for sharing the current directory with the container's /app/project for inputting data and accessing it, and mentions sharing a .env file with the API keys through the same mechanism. Note that the compose.yaml in the repository takes a different approach for local development, building from docker/Dockerfile.dev and mounting the whole directory at /app:

services:
  denario:
    build:
      context: .
      dockerfile: docker/Dockerfile.dev
    ports:
      - 8501:8501
    volumes:
      - .:/app

For a local source build, the documented command is docker build -f docker/Dockerfile.dev -t denario_src ., which pairs with the compose file.

A repo full of examples is the fastest way to learn the shape

The examples directory is the most underused part of the repository, and it is more informative than the prose documentation.

There is a full_workflow.py file that shows the whole sequence in one script, and the notebooks are named after the stages they demonstrate: research_idea.ipynb, write_paper.ipynb, get_keywords.ipynb, idea_check.ipynb, oscillator_full_run.ipynb, and enhance_input.ipynb. The names tell you what the pipeline actually supports in practice. A keyword extraction step, an idea check step, an oscillator full run as a worked numerical example, and an input enhancement step are all first class features, not just the happy path from idea to paper.

There are also data directories: examples/GW231123, examples/Project1 and examples/Project2. GW231123 is a gravitational wave event naming convention, which tells you the kinds of datasets this was developed against.

The end-to-end claim is checkable too. The resources list includes a repository of end to end research papers generated with Denario, separate from the DenarioExamplePapers name used for the examples, and the update log records that a paper fully generated with Denario was accepted for publication at the Open Conference of AI Agents for Science 2025. For a research assistant, an output you can read end to end is more convincing than a description of what it intends to do.

Where the pipeline will not substitute for a reviewer

The limitation is structural and worth stating plainly. The results stage performs computations and produces the results, and the code performing those computations was written by an agent, not by you. Nothing in the documentation describes validation of the numbers, error bars, or cross-checking against an independent implementation. A reviewer who reads a Denario draft has to redo the science, which is the expensive part, so the pipeline saves you writing and formatting rather than thinking.

There is a second limitation in the ecosystem choices. The agents call OpenAI, Claude and Gemini through LangChain integrations, so a run depends on hosted services, on network access, and on those providers accepting the API keys you provide. Reproducing a run later also depends on model behaviour, which is not pinned by the package versions in pyproject.toml.

A third point is about the framing rather than the code. The update log is a list of recognitions: a mention in the LSST DESC AI Roadmap, and cmbagent winning first place at the NeurIPS 2025 Fair Universe Competition. Those are signals that the community has looked at the work. They are not evidence that the pipeline produces correct research, and the difference matters when you are deciding whether to let it write your methods section.

GPL-3.0 on the package, Apache 2 on the backend

The licence situation is worth understanding because it is split across two projects. Denario is released under GPL-3.0, and the project metadata declares license as GPLv3 with the badge pointing at the GNU GPL version 3 page. The documentation states that Denario and Cmbagent are open source software projects under GPL-3 and Apache 2 licences respectively, and that no private or public organisations or individuals other than the three copyright holders can claim IP or ownership on these software packages.

That last clause is unusual and worth reading literally. It is a statement about ownership of the software packages rather than about trademark or about the papers the system produces. It does not tell you anything about the copyright status of a paper the system generates, and anyone who needs to publish under their own name should work that out separately rather than assuming the package licence transfers.

The package requires Python 3.12 or newer, with pyproject.toml constraining it to >=3.12,<3.14, and the README badges indicate Python 3.12 support. The console entry point is denario = "denario.cli:main", so the command line interface is a thin wrapper over the CLI module.

The repository also carries a compose.yaml, a docs directory with mkdocs as the documentation stack, a tests directory, and a .readthedocs.yaml, which means the readthedocs documentation is built from this repository rather than maintained separately.

Editorial conclusion

Denario suits a computational science group that wants an end to end draft of a paper from an existing dataset, with plots, computed results and journal formatting handled by the pipeline rather than by hand. It is the wrong tool if you need reliable numbers, since the results come from code an agent writes and you must review them, and the wrong tool for a closed environment because it calls hosted OpenAI, Claude and Gemini models. Before adopting it, run the get_idea and get_method steps on a small dataset and read the intermediate markdown it produces, then check the Docker route with docker run -p 8501:8501 --rm pablovd/denario:latest if you want LaTeX without a local TeX install.

Frequently asked questions

Official sources

1. Denario-AI/Denario on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases