# CopilotKit/open-research-ANA: a Human-in-the-Loop research canvas you run yourself > ANA is a demo of an agent-native research canvas: a LangGraph agent does Tavily searches while a CopilotKit frontend lets you approve or redirect the work. The repository is now a pointer to the CopilotKit monorepo, and that is the first thing to understand before you clone it. **CopilotKit/open-research-ANA** — 🤖 An open-source, AI agent-native research canvas application that performs real-time search with HITL (Human in The Loop) capabilities, powered by CopilotKit, Tavily and LangGraph - Repository: https://github.com/CopilotKit/open-research-ANA - Website: https://open-research-ana.vercel.app - Stars: 411 · Forks: 112 - Language: TypeScript - License: not declared - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/copilotkit-open-research-ana ## What open-research-ANA actually is, and who it is for The README calls this repository a demo. That word does most of the work. ANA is an agent-native research canvas: you ask a question, a LangGraph agent searches the web through Tavily, and the canvas fills with findings while you stay in the loop. The topics list names the pieces: agent-native, canvas, hitl, langgraph, tavily, copilotkit. The primary language is TypeScript, and the repository root holds only .gitignore, README.md, agent/, frontend/ and renovate.json. There is no docs directory, no test suite and no published release. The audience is narrower than the topic list suggests. This is for engineers who already work with CopilotKit or LangGraph and want a reference implementation of a canvas UI wired to a stateful agent, including the human approval step. It is not a tool an analyst installs to do research. Nothing in the repository suggests packaging, a hosted version you control, or a support commitment. The homepage points at a Vercel deployment, which is a demo instance, not a service. The most important line in the README is the note at the bottom. The project has been consolidated into the CopilotKit monorepo, and the latest version lives at examples/showcases/research-canvas. This repository is a signpost. Anyone cloning it today is reading a snapshot, not a maintained codebase. ## The agent and the canvas: how the pieces fit The README splits the project into two components and says so plainly: the agent and the frontend. The agent is a LangGraph application, started with the LangGraph CLI, which by default serves it on port 8123. The frontend is a Next.js app under frontend/, installed with pnpm and started with pnpm run dev. Between them sits CopilotKit. The README's tunnel step is the tell: npx copilotkit@latest dev --port 8123 opens a tunnel to the local agent so the frontend can reach it. CopilotKit is acting as the agentic interface layer, mediating between the browser canvas and the running graph. The CoAgents documentation linked from the README is the place the project expects you to read for the mechanics. The human-in-the-loop capability is the reason the canvas exists rather than a chat window. A research agent that only streams text gives you no way to intervene. Here the agent's state is exposed to a UI, so the user can approve or redirect while the graph is running. Tavily supplies the real-time search results that feed that state. LangSmith appears in the environment files for tracing, not for search. What the README does not document is the graph topology itself: how many nodes, which node performs the search, where the interrupt is placed. That lives in agent/, and you have to read the code. ## Installing open-research-ANA and running your first search The README lists three prerequisites: pnpm, Docker and the LangGraph CLI. Docker is there because langgraph up runs the agent in a container. You also need four API keys before anything starts: OpenAI, Tavily, LangSmith and CopilotKit. Start with the agent. The README gives this exact sequence, creating .env inside agent/ and then starting the graph: ```bash cd agent cat << EOF > .env OPENAI_API_KEY=your_key TAVILY_API_KEY=your_key LANGSMITH_API_KEY=your_key EOF langgraph up ``` After langgraph up, watch the output for the API URL. The README's example is http://localhost:8123. The frontend needs to reach that address, and the next command is how the README does it: ```bash npx copilotkit@latest dev --port 8123 ``` That command creates a tunnel to your local agent. Keep it running in its own terminal. Now the frontend, which has its own .env with three keys (note that Tavily is not among them, because search happens agent-side): ```bash cd frontend pnpm install cat << EOF > .env OPENAI_API_KEY=your_openai_key LANGSMITH_API_KEY=your_langsmith_key NEXT_PUBLIC_COPILOT_CLOUD_API_KEY=your_copilot_cloud_key EOF pnpm run dev ``` When pnpm run dev finishes compiling, open the local URL it prints. You should see the research canvas. Type a research question and the agent should begin searching through Tavily, with the canvas updating as it goes and the human-in-the-loop controls available while the graph runs. If the canvas loads but the agent never responds, the tunnel is the first thing to check, since the frontend talks to the agent through it. ## Where this demo breaks down The licence is the hardest problem. The repository metadata gives no licence, and the README does not state one. Without a licence, the default is that you have no granted rights to redistribute or reuse the code, whatever the public repository suggests. That is not a detail you can defer if you plan to build on it. It is also the kind of thing that gets resolved in the monorepo rather than here, so check the CopilotKit monorepo's licence before you copy anything. The second problem is that this repository is not where the code is developed. The README says the project has been consolidated into the CopilotKit monorepo and asks for issues and pull requests there. A bug you find in this snapshot may already be fixed, or may be irrelevant, at examples/showcases/research-canvas. The last push to this repository was on 2026-09-06, so the snapshot is recent, but recent is not the same as current. Operationally, the demo assumes a local agent plus a tunnel. That is fine on a laptop and awkward anywhere else. There is no documented deployment path for the agent, no rollback guidance, and no statement about what happens to in-flight research when the tunnel drops. Four API keys, one of them for LangSmith tracing, is also a lot of surface area for something you are evaluating rather than shipping. Finally, the wrong-tool case: if your goal is to answer research questions, this is a poor choice. You would be running a Next.js app, a containerized LangGraph agent and a tunnel to get what a hosted research assistant gives you in a browser tab. The value here is the integration pattern, not the research output. ## open-research-ANA against CopilotKit's own research canvas The obvious alternative is the copy of this project inside the CopilotKit monorepo, at examples/showcases/research-canvas. The difference is not technical, it is structural. This repository is a standalone demo with its own agent/ and frontend/ directories, its own package setup and its own issue tracker that the README tells you not to use. The monorepo version sits inside a larger project with its own release process and its own licence, and it is the version the README calls the latest. If you want to read the integration in isolation, with nothing else in the tree, this repository is easier to navigate: five top-level entries, two of them the actual components. If you want the code that is actually maintained, the monorepo path is the one to clone. Choosing this repository means accepting that fixes land somewhere else. A second comparison is against building the same canvas directly on LangGraph's own platform tooling without CopilotKit. That removes the tunnel step and the CopilotKit Cloud key, and it removes the ready-made agentic UI layer. You would be writing the canvas-to-graph state plumbing yourself. The README does not argue for either approach; it links to the CopilotKit CoAgents docs and the LangGraph Platform deployment docs and leaves the decision to you. ## Maintenance, upgrade cost and the licence question Treat this repository as frozen. The README's consolidation note means development happens in the CopilotKit monorepo, and the practical upgrade path is to switch your remote to that repository rather than to pull changes here. The last push was on 2026-09-06, which tells you the snapshot is fresh but not that this is the maintained copy. Upgrade cost is dominated by the external services, not the code. The agent needs OpenAI, Tavily and LangSmith keys; the frontend needs OpenAI, LangSmith and a CopilotKit Cloud key. Each of those has its own versioning and pricing, and the README links to their signup pages rather than pinning versions. A dependency bump in the monorepo can change the agent's behaviour without anything in this repository changing at all. On licensing: the repository provides no licence identifier, and I am not going to guess at one. The safe reading is that no rights are granted until you find a licence file, and the place to look is the CopilotKit monorepo, since that is where the README says the project now lives. If you need a permissive licence for commercial use, resolve that before you write a line of code against this. This is not legal advice; it is a statement about what the repository does and does not contain. ## Conclusion Adopt it if you are building an agent-native canvas and want a working reference for CopilotKit's LangGraph integration, human approval steps and Tavily search, and if you accept that the code now lives in the CopilotKit monorepo rather than here. Do not adopt it if you need a supported product with releases, a documented licence or a migration path, because this repository has none of those. Before you start, check the examples/showcases/research-canvas path in the CopilotKit monorepo still exists, and confirm what each of the four API keys costs you. ## FAQ ### What does "open research" mean in open-research-ANA? In this project the term describes an open-source research canvas rather than a definition of research itself: an agent-native application that performs real-time search through Tavily and keeps a human in the loop, with the source published in the CopilotKit repository. ### What does open source research mean here? For open-research-ANA it means the demo's code is published and readable, with the agent and frontend components in the repository. It does not mean a licence is granted, because the repository states no licence and the README points to the CopilotKit monorepo as the maintained home. ### Is open-research-ANA one of the top research tools? The README presents it as a demo of an agent-native research canvas rather than a finished research tool, and it documents no releases or deployment path for the agent. It is best read as a reference implementation of CopilotKit, LangGraph and Tavily working together. ## Sources - [CopilotKit/open-research-ANA on GitHub](https://github.com/CopilotKit/open-research-ANA) - [Issues](https://github.com/CopilotKit/open-research-ANA/issues) - [Project website](https://open-research-ana.vercel.app) - [README](https://github.com/CopilotKit/open-research-ANA/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/copilotkit-open-research-ana