FAROS: Best AI Research Orchestration for LLM Teams in 2026

What Is FAROS?

FAROS is one of the best AI Research Orchestration tools for LLM researchers and research automation teams. Built by OpenNSWM-Lab, FAROS turns blueprint-driven AutoResearch workflows into a runnable Python 3.11+ and Node.js 18+ runtime for idea selection, experiment scaffolding, LaTeX paper generation, and reviewer simulation, and this snapshot already shows 10 passing tests plus a 1.1.0-rc1 baseline.

The important detail is that FAROS is not framed as a single agent prompt wrapper. It is a workflow runtime with explicit Blueprints, Capabilities, Profiles, and Providers, which makes it closer to a research operating system than a chatbot front-end.

Quick Overview

Who Should Use FAROS?

• Research teams building repeatable LLM pipelines that need a typed workflow boundary instead of an ad hoc prompt chain.
• Indie hackers and lab engineers who want to move from idea generation to paper artifacts with one local runtime.
• Platform engineers who need a clear separation between workflow definition, provider selection, memory, and artifact storage.
• Agent framework builders who want a research-specific runtime model that can be extended beyond a single model provider.

Not ideal for:

• Teams that need a finished, polished frontend console today, because the release scope says the FAROS frontend console is not yet included.
• Groups that require full DAG scheduling and parallel orchestration right now, because the current runtime is still a sequential baseline.
• Users who want a non-LLM provider ecosystem on day one, because this release is centered on the FAROS-LLM baseline.

Key Features of FAROS

• Blueprint-driven workflow contracts — FAROS uses a blueprint to define the workflow graph, constraints, output contract, and validation rules. That is a cleaner model than stuffing state into one giant agent prompt, because the runtime can validate each stage separately.
• Capability and provider registries — FAROS splits execution into Capabilities and Providers, so the same research step can be backed by an LLM, a tool API, or a human review path. This matters when you want to swap engines without rewriting the orchestration layer.
• File-backed persistence — Runs, events, artifacts, and memory are persisted on files in the current release. That keeps the system easy to inspect locally and avoids forcing a database dependency before the runtime is ready.
• Module-native reuse — The repository reuses the existing idea, code, paper, review, and platform modules through FAROS capability adapters instead of creating a second parallel application. That reduces duplication and keeps the domain logic in one place.
• Venue-aware LaTeX generation — FAROS can produce a latex_project, a compiled paper_pdf, and fallback rendered PDF artifacts. That is a real advantage for research workflows where the output is not just text, but submission-ready paper assets.
• Structured review loop — The reviewer_simulation stage emits structured feedback plus follow-up items, which is more useful than a vague critique blob. It gives teams actionable outputs that can feed the next iteration.
• Current LLM workflow baseline — The first runnable chain is idea -> experiment -> paper -> review, exposed through the ml_paper blueprint and faros_llm profile. That makes FAROS immediately useful for paper-centric LLM experimentation, even before cross-domain abstraction lands.

FAROS vs Alternatives

Pick FAROS when the problem is not just running agents, but preserving a research contract from idea to paper to review. Pick OpenSwarm when you need more generic orchestration across varied tasks and want agent coordination to stay flexible.

Choose Brainstorm MCP if the team spends most of its time filtering and ranking ideas before any execution happens. Choose OpenTrace if you already have an execution stack and need better visibility into what happened during each run.

How FAROS Works

FAROS works by binding a Blueprint to a Profile, then resolving the required capabilities and providers through registries before execution starts. The architecture is intentionally layered: the blueprint describes the workflow, the capability implements a step, the provider supplies the engine, and the orchestrator coordinates the sequence while persisting events, artifacts, and research memory.

That design keeps the runtime boundary clean. Instead of coupling idea refinement, experiment scaffolding, paper drafting, and reviewer simulation into one monolithic model call, FAROS stores each step as a typed artifact and verifies the baseline as the workflow moves forward.

The current implementation is sequential rather than fully parallel, which is why the release scope calls out missing DAG scheduling. That is a trade-off, but it also makes the system easier to reason about while the first domain is still being stabilized.

cd backend
pip install -r requirements.txt
uvicorn app.main:app --host 127.0.0.1 --port 8005 --reload

The commands above start the backend runtime on localhost and expose the FAROS API layer for the research workflow. In practice, you should expect the orchestrator to load the ml_paper blueprint, bind the faros_llm profile, and then drive the idea_refinement, experiment, paper_drafting, and reviewer_simulation stages in order.

Pros and Cons of FAROS

Pros:

• Clear runtime boundary — blueprint, capability, profile, and provider are separate concerns, which makes the system easier to extend without turning the codebase into a prompt soup.
• Research-native artifacts — FAROS tracks idea_session, code_project, experiment_record, latex_project, paper_pdf, and review_report, so the outputs are immediately useful for real research workflows.
• Local debugging friendly — file-backed persistence and explicit stage outputs make it easy to inspect what happened without depending on a heavy platform layer.
• Reusable module surfaces — the existing domain modules are kept intact and adapted into FAROS instead of being thrown away.
• Submission-focused output — venue-aware LaTeX generation makes FAROS more serious than tools that stop at text generation.

Cons:

• No full DAG scheduler yet — if your workflow needs parallel branches, retries across a graph, or asynchronous fan-out, the current release is not there.
• No DB-backed runtime metadata yet — file-backed storage is good for local development, but it will not satisfy every team’s production observability and query needs.
• No mature cross-domain blueprint library — the release is intentionally focused on the LLM domain first, so broader reuse still needs more work.
• No finished frontend console — the repository references a frontend, but the scope notes that the FAROS frontend console is not yet included as a final experience.
• Non-LLM provider support is still thin — the runtime is being shaped for future provider classes, but this release is still centered on FAROS-LLM.

How FAROS Works

FAROS is built around a small but strict set of abstractions: Blueprints define the workflow contract, Capabilities implement each stage, Profiles choose how the workflow runs, and Providers execute the underlying model or tool call. That separation is the main architectural decision, because it prevents the orchestration layer from becoming tied to one model vendor or one research template.

The repository layout reinforces that split. backend/app/faros contains the runtime, registries, loaders, models, memory, verification, and API code, while the domain modules under backend/app/modules carry reusable implementation logic for idea, code, paper, review, and platform surfaces.

The execution path is intentionally opinionated. FAROS loads the blueprint, resolves the profile, executes stage-by-stage, records events and artifacts, and then runs baseline verification against the expected research outputs. That makes the system predictable for developers who care about reproducibility, not just one-off generation.

cd backend
pip install -r requirements.txt
uvicorn app.main:app --host 127.0.0.1 --port 8005 --reload

This boot sequence starts the API server that wraps the runtime. Once it is running, the next expectation is configuration of a real LLM provider, because the repository explicitly says a configured provider is required for real execution rather than only baseline startup.

Getting Started with FAROS

The fastest path is to install the backend dependencies, launch the API server, and then start the frontend if you want the UI shell. The repository also notes latexmk and pdflatex as runtime requirements for venue-style PDF compilation, so install those early if paper generation is part of your workflow.

git clone https://github.com/OpenNSWM-Lab/FAROS.git
cd FAROS/backend
pip install -r requirements.txt
uvicorn app.main:app --host 127.0.0.1 --port 8005 --reload

cd ../frontend
npm install
npm run dev

After the backend starts, FAROS can load the ml_paper blueprint and the faros_llm profile, but real execution still depends on your LLM provider configuration. If you are testing paper generation locally, make sure latexmk and pdflatex are installed, otherwise PDF compilation will fall back or fail at the paper stage.

Verdict

FAROS is the strongest option for blueprint-driven research automation when you need a reproducible LLM workflow instead of a generic chat agent. Its key strength is the explicit separation of workflow, capability, profile, and provider; the caveat is that the current release still lacks full DAG scheduling and a finished console. Use it when the research loop itself is the product.