open-research-ANA: a CopilotKit research canvas that has already moved to the monorepo

The gap between a chat window and a research artefact

Most agent demos end at a text box. You ask, the model answers, the answer scrolls away. open-research-ANA takes the opposite shape: the output is a canvas, and the agent writes into it. The README describes it as a research canvas app that pairs human-in-the-loop capabilities with Tavily's real-time search and CopilotKit's agentic interface, running on LangGraph. The intended user is a developer who wants to see what an agent-native application looks like when the agent has a persistent surface to edit rather than a single reply to produce. The human-in-the-loop part matters here. Research is a task where a wrong branch early costs a lot of tokens later, so the design keeps a person in the loop instead of letting the graph run to completion unattended. If you are evaluating CoAgents and want a concrete application to read, this is the kind of sample that shows the wiring end to end. If you want a tool to hand to a research analyst tomorrow, this is not that, and the repository itself says so by pointing elsewhere.

Two processes, four keys, and a tunnel between them

The architecture splits cleanly. There is an agent directory holding a LangGraph graph, and a frontend directory holding a Next.js app. They are not one process. The agent runs under the LangGraph CLI, which the README starts with langgraph up and which prints a local API URL, given as http://localhost:8123 in the example. The frontend then talks to that agent through a tunnel created by npx copilotkit@latest dev --port 8123. That tunnel is the piece people miss when they try to reproduce the demo: the browser is not calling localhost directly, it is calling a development endpoint that CopilotKit provisions and that forwards to your machine. Tavily supplies the search results the agent reasons over, so the retrieval step is an external HTTP call rather than a local index. LangSmith sits alongside for tracing, which is why it appears in both .env files even though it is not what makes the demo function. The data flow is therefore: user edits or prompts on the canvas, CopilotKit relays to the LangGraph agent through the tunnel, the agent calls Tavily, and results come back into the shared state the canvas renders. The README does not document the graph's node structure, so treat any claim about specific nodes or state keys as unverified until you read the source.

Getting it running: the exact commands from the README

Prerequisites are pnpm, Docker, and the LangGraph CLI. Docker is not optional decoration; the LangGraph CLI uses it to run the agent runtime locally. Start the agent first. From the repository root, cd agent, then create .env with OPENAI_API_KEY, TAVILY_API_KEY, and LANGSMITH_API_KEY. The README gives the heredoc form: cat << EOF > .env followed by the three assignments and EOF. Then run langgraph up and note the API URL from the output. Second, open the tunnel with npx copilotkit@latest dev --port 8123. Third, cd frontend, run pnpm install, write a second .env containing OPENAI_API_KEY, LANGSMITH_API_KEY, and NEXT_PUBLIC_COPILOT_CLOUD_API_KEY, then pnpm run dev. Note that the frontend key names differ from the agent's: the CopilotKit Cloud key is prefixed NEXT_PUBLIC_ because the browser needs it, and there is no TAVILY_API_KEY on the frontend side. That asymmetry is worth respecting when you copy the files, because pasting the agent's .env into frontend/ will leave the app without a CopilotKit Cloud key and it will not connect.

Four accounts before the first token, and no stated licence

The cost of entry is not the code, it is the accounts. OpenAI, Tavily, LangSmith, and CopilotKit Cloud are all required for the local setup as documented. Tavily's pricing page is linked directly in the README, which tells you the search calls are metered. LangSmith is metered separately, and although tracing is optional in principle, the documented .env includes it, so a reader following the README exactly will sign up for it. Add Docker Desktop and a Node toolchain and the barrier is real for what is, by the author's own framing, a demo. The licence is the sharper problem. The repository metadata supplied here lists the licence as unknown, and the README says nothing about licensing. That is not a nuance you can wave away: without a licence file, the default position under most jurisdictions is that no rights are granted beyond what the platform's terms allow, so copying the agent code into a commercial product is a decision to make with a lawyer, not a decision to make from a README. Check the monorepo's licence for the research-canvas directory before reusing anything, because the licence that applies there is the one that matters, not whatever this repository does or does not contain.

The README redirects you, and that changes the maintenance answer

The most important line in the README is the note that the project has been consolidated into the CopilotKit monorepo, with the current version at examples/showcases/research-canvas, and that issues and pull requests should go to the main CopilotKit repository. Read that as a maintenance statement. This repository is a snapshot. Bug reports filed here will not be triaged here. If the tunnel command changes, or CopilotKit Cloud's key handling changes, or the LangGraph CLI's up command is replaced, the fix lands in the monorepo and this copy drifts. The last push date in the metadata is recent, which can be misleading: activity on a repository that has been superseded does not mean the code here is the code being maintained. For a team deciding where to spend reading time, the practical move is to open the monorepo path first and use this repository only if that path is gone. Upgrade cost is therefore near zero in one sense (you do not maintain this copy) and non-trivial in another (you must track a directory inside a large monorepo whose release cadence you do not control).

Where this is the wrong tool, and what to read instead

This is the wrong tool if you need a research assistant with an audit trail, a stable API, or a licence you can point at. It is also the wrong tool if your team cannot run Docker locally, since the documented agent startup path depends on it. And it is the wrong tool if you want to avoid vendor accounts: the four-key requirement is structural, not incidental, because the search layer is Tavily and the agent transport is CopilotKit Cloud. A real alternative for the retrieval half is to drop Tavily and put a self-hosted search backend or a plain HTTP fetch tool behind the same LangGraph node, which removes one metered dependency and one signup; the difference in approach is that you own the index and the freshness problem instead of renting it. On the agent-transport side, the alternative is to skip CopilotKit and expose the LangGraph agent over its own HTTP endpoint, calling it from your frontend directly. That removes the tunnel and the Cloud key, and it also removes the shared-state and human-in-the-loop plumbing that CopilotKit exists to provide, so you would be rebuilding the interesting part of this demo yourself. Choose that path only if the CoAgent model is not what you are evaluating.

Who should read this repository, and what to check first

Read it if you are learning how a LangGraph agent and a browser canvas share state, and you want a small, complete example rather than a framework's documentation. The two-directory split, the separate .env files with different key names, and the tunnel step are the details that documentation tends to smooth over, and seeing them laid out is useful. Do not start here if you are looking for the maintained version, because the README tells you where that is. Do not start here if you need a licence, because none is stated. Before you invest a day in reproducing the setup, verify three things in order: that examples/showcases/research-canvas still exists in the CopilotKit monorepo and what licence covers it, that the langgraph up command and the npx copilotkit dev tunnel still behave as the README describes for your installed CLI versions, and that the four API keys are ones your organisation is willing to create. If the monorepo path is gone, this repository becomes a historical artifact and the honest answer is that the demo is no longer supported anywhere.

Editorial conclusion

Adopt open-research-ANA as a reading exercise for CoAgent wiring, and read examples/showcases/research-canvas in the CopilotKit monorepo instead if you want the maintained copy. Skip it if you need a deployed research tool with a licence you can verify, since the repository states no licence and the README redirects issues and pull requests elsewhere. Before copying anything, confirm the monorepo path still exists, check what licence the monorepo applies to that directory, and total up the four keys (OpenAI, Tavily, LangSmith, CopilotKit Cloud) plus Docker and the LangGraph CLI, because the demo does not run without all of them.

Official sources

1. CopilotKit/open-research-ANA on GitHub
2. Issues
3. Project website
4. README