# OpenAgent: a Flask and LangGraph harness for vertical AI agents

> OpenAgent bundles a Flask backend, Celery workers and a Vue 3 workspace into one platform for building, publishing and operating AI apps. It is aimed at teams that want Deep Research style reasoning and visual workflows in the same deployment.

**Haohao-end/openagent** — What if OpenAI Deep Research and Dify were one platform? OpenAgent — harness architecture for rapidly building vertical AI agents, with deep reasoning loops, visual workflows, RAG, and A2A delegation. 

- Repository: https://github.com/Haohao-end/openagent
- Website: https://openllm.cloud
- Stars: 807 · Forks: 82
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/haohao-end-openagent

## The problem OpenAgent targets: agents that never leave the demo stage

Most agent projects stop at a chat loop. You get a script that calls a model, maybe a tool or two, and then the hard part begins: where do prompts live, who owns the dataset, how does a non-engineer publish the result, and what serves it to the outside world. OpenAgent positions itself against that gap. The README describes it as an end-to-end platform for building, orchestrating, publishing and operating AI applications, and the repository layout backs that up: api/ for the Flask service, ui/ for the Vue 3 workspace, docker/ for the Compose stack, scripts/ for operational helpers.

The intended user is a team building vertical agents, meaning an agent scoped to one domain rather than a general assistant. The README lists draft, publish, analysis, version comparison and prompt comparison as workspace flows, which is the vocabulary of a product team iterating on an app, not a researcher running a notebook. If your workflow is one developer and one terminal, the platform layer here is overhead you will pay for in RAM and configuration.

## How the harness works: Flask, Celery, LangGraph and two vector stores

The architecture is a conventional multi-service split. Flask and SQLAlchemy sit behind the REST API, Celery workers handle asynchronous work with Redis as the broker, PostgreSQL is the relational store, and Weaviate and FAISS appear as vector stores for retrieval. The frontend is Vue 3 with Vite, Pinia and Vue Flow, the last of which is what the visual workflow canvas is built on.

Orchestration is where the project's own framing matters. The README lists LangChain and LangGraph under AI framework and orchestration, alongside tool calling, A2A delegation, skills and memory. A2A delegation is the mechanism behind the home assistant routing requests to published public agents, and it is also what lets one agent hand work to another. The Deep Research feature is described as letting an app decompose complex tasks and coordinate bound capabilities across multi-step execution. That is a reasoning loop over the capabilities you have bound to the app, not a separate research product.

Delivery is deliberately plain. Published apps are exposed over REST and SSE through POST /api/openapi/chat, so an app you build in the workspace becomes an HTTP endpoint. Nginx sits in front as the reverse proxy. The trade-off is visible: you get a stable integration surface, but you own every service in that chain.

## Installing OpenAgent with Docker Compose and running it for the first time

The README documents Docker 20.10+ and Docker Compose 2.x as prerequisites, recommends 8 GB+ RAM for the full stack, and requires access to at least one supported model provider API key. Start by cloning and creating the runtime environment file, which the README shows as a copy of the example file.

```bash
git clone https://github.com/Haohao-end/openagent.git
cd openagent
cp api/.env.example api/.env
```

Before starting anything, open api/.env and set the minimum required values the README names: JWT_SECRET_KEY, POSTGRES_PASSWORD, REDIS_PASSWORD, WEAVIATE_API_KEY, VITE_API_PREFIX, and at least one provider key such as OPENAI_API_KEY, ATLASCLOUD_API_KEY, DEEPSEEK_API_KEY or DASHSCOPE_API_KEY. The stack will not be useful without a provider key, so treat that as part of setup rather than a later step.

```bash
cd docker
docker compose up -d --build
```

After the build completes, the README lists three local endpoints: the Vue 3 frontend on http://localhost:3000, the Flask REST API on http://localhost:5001, and Nginx on http://localhost. If the frontend loads but API calls fail, the reverse proxy or the API prefix is the first place to look, since the frontend resolves its API base from VITE_API_PREFIX.

For backend work outside Docker, the README gives a plain Flask run on port 5001 after installing api/requirements.txt; the frontend uses npm run serve and Vite defaults to port 5173. Tests are split: pytest in api/, and npm run type-check, npm run lint, npm run build and npm run test:unit -- --run in ui/.

## Where OpenAgent gets in your way

The full stack is heavy by design. PostgreSQL, Redis, Weaviate, Celery workers, Flask, Nginx and a Vite frontend all need to be running before the platform is fully functional, and the README's own 8 GB+ RAM recommendation reflects that. On a laptop, running the API and frontend locally while the data services stay in Compose is the more practical split, but it means two configuration paths to keep in sync.

Retrieval is the second sharp edge. Weaviate and FAISS are both listed, and the README describes semantic, full-text and hybrid retrieval as capabilities. Which store backs which path, and how you switch between them, is not spelled out in the README. If your evaluation depends on a specific retrieval mode, confirm that in the code before you build on it.

The README also does not document rollback for published apps or workflows. Version comparison exists in the workspace, but restoring a previous published version is not described. Teams that need an audited release process should treat that as an open question rather than assume the UI covers it. Finally, this is the wrong tool if you want a CLI agent that lives in your terminal. The whole value proposition here is the platform around the agent, and a single-purpose coding assistant does not need PostgreSQL or a workflow canvas.

## OpenAgent compared with Dify and single-purpose agent CLIs

The README frames the project as what you would get if OpenAI Deep Research and Dify were one platform, and Dify is the closest reference point: a self-hosted workspace with visual workflows, datasets and app publishing. The difference in approach is the reasoning layer. OpenAgent puts Deep Research, A2A delegation and skills in the same harness as the workflow editor, so a published app can decompose a task and coordinate bound capabilities rather than only execute a fixed graph. Whether that matters depends on whether your agents need multi-step reasoning at runtime or a deterministic flow is enough.

Against terminal-based agent CLIs, the split is architectural rather than feature-level. A CLI agent is a process you invoke; OpenAgent is a service you operate, with an OpenAPI delivery path through POST /api/openapi/chat and SSE streaming. If your consumers are other systems calling an endpoint, the platform shape is the point. If your consumer is you, at a prompt, it is a lot of machinery.

## Licence, maintenance and what an upgrade costs

OpenAgent is MIT licensed, which permits commercial use and modification, with the usual requirement to preserve the copyright notice and licence text. The repository also carries a SECURITY.md and a CODE_OF_CONDUCT.md, so there is a stated process for reporting issues. This is not legal advice; check the LICENSE file and your own obligations.

The last push to the repository was on 2026-07-17, and the most recent tagged release is v1.1.4 from 2026-06-15, following v1.1.3 and v1.1.2 in the weeks before. The release cadence in that window was roughly every two to three weeks. The repository is not archived.

Upgrade cost is dominated by the service topology, not the Python code. Because the stack is defined in docker/, an upgrade means rebuilding images and reconciling api/.env against api/.env.example, which is where new required variables tend to appear. If you have modified the workflow canvas or the retrieval configuration, budget time for the Weaviate and FAISS side separately, since the README does not describe a migration path between them.

## Conclusion

Adopt OpenAgent if you need a self-hosted workspace where the same deployment holds visual workflows, datasets and a Deep Research loop, and you are willing to run PostgreSQL, Redis and Weaviate alongside it. Skip it if you want a single-binary CLI agent or a managed service with no infrastructure to own. Before committing, verify that api/.env.example lists every variable your deployment needs, that the model provider you intend to use has a key entry, and that the docker compose stack comes up on the ports the README documents.

## FAQ

### What is OpenAgent?

OpenAgent is an end-to-end AI agent platform for building, orchestrating, publishing and operating AI applications, with a Flask and LangChain/LangGraph backend and a Vue 3 workspace. It combines visual workflows, datasets, tools and OpenAPI delivery in one deployment.

### How do I use OpenAgent?

Clone the repository, copy api/.env.example to api/.env and set the minimum required values including JWT_SECRET_KEY, POSTGRES_PASSWORD, REDIS_PASSWORD, WEAVIATE_API_KEY and at least one provider API key. Then run docker compose up -d --build from the docker directory and open the frontend on http://localhost:3000.

### Is OpenAgent legitimate?

The repository is public, MIT licensed, not archived, and its last push was on 2026-07-17, with v1.1.4 released on 2026-06-15. It also ships a SECURITY.md and a CODE_OF_CONDUCT.md, and the README links to a website and API documentation.

### What is openagent?

According to the README, it is a full-stack platform for teams building AI applications rather than a single chat demo, combining a Flask backend, Celery workers, a Vue 3 frontend, visual workflow authoring, dataset management and OpenAPI-based delivery.

## Sources

- [Haohao-end/openagent on GitHub](https://github.com/Haohao-end/openagent)
- [License: MIT](https://github.com/Haohao-end/openagent/blob/main/LICENSE)
- [Project website](https://openllm.cloud)
- [README](https://github.com/Haohao-end/openagent/blob/main/README.md)
- [Releases](https://github.com/Haohao-end/openagent/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/haohao-end-openagent