# Choose an Agent Starter: Inspect Three Repositories and Test One

> Compare a Python agent backend, a LangGraph chat UI and a full-stack chatbot, then reproduce a pinned starter inspection without paid inference.

- Source: https://www.zarifautomates.com/blog/best-ai-agent-template-libraries-and-starters
- Published: 2026-09-17
- Updated: 2026-09-19
- Pillar: Agents & AI Engineering
- Tags: agent-course, ai-engineering, practical-guide
- Author: Zarif

---

A starter saves work only if it supplies the part of the system you actually need. A chat interface is not an agent backend. A tool loop is not an authenticated application. A full-stack demo can introduce a database, file storage and provider account before you have settled the task.

This lesson compares three official repositories with different purposes, then inspects one at a fixed revision. You will reproduce its local unit tests and a small probe of routing, step limits and configuration. The probe uses a fake model. No hosted deployment, live model response or search result is claimed.

## Choose the layer you are missing

These repositories were checked on September 17, 2026. None was marked archived in GitHub's API. The activity dates below describe the inspected default-branch revisions. They do not guarantee a response time, maintenance policy or production suitability.

| Repository | What you receive | Inspected revision date | Main setup obligations |
| --- | --- | --- | --- |
| [LangGraph ReAct Agent](https://github.com/langchain-ai/react-agent) | Python graph with a model/tool loop and a Tavily search example | August 28, 2026 | Python environment; model and search credentials for a live run |
| [Agent Chat UI](https://github.com/langchain-ai/agent-chat-ui) | Next.js interface for a LangGraph server with a `messages` state key | September 14, 2026 | Node/pnpm plus an existing compatible backend; production authentication design |
| [Vercel Chatbot](https://github.com/vercel/chatbot) | Full-stack Next.js/AI SDK chat application with history, authentication and file storage integrations | July 8, 2026 | Provider or gateway access, database, storage and application environment variables |

The first two repositories carry MIT licenses. The inspected Vercel license file states Apache License 2.0. GitHub's metadata returned `NOASSERTION`, so the file was checked directly. Read the actual license and dependency terms for your use case rather than treating a badge as the complete answer.

For the course's Python ticket task, the ReAct template is the smallest relevant backend starting point among these three. Agent Chat UI becomes useful after that backend exists. Vercel Chatbot is a different starting point when the product itself is a web chat application and its additional services are justified. The [repository directory](/blog/best-ai-agent-repos-and-starter-templates) offers a wider set of candidates.

## Pin the ReAct template before evaluating it

The inspected revision is `9bbd82d84905acc37f527b1f372dae841016f3b4`. Its `pyproject.toml` requires Python 3.11 or newer, below 4.0. The checks here used Python 3.12.14. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) if it is not already available, then use a disposable checkout:

```bash
git clone https://github.com/langchain-ai/react-agent.git
cd react-agent
git checkout 9bbd82d84905acc37f527b1f372dae841016f3b4
uv sync --frozen --python 3.12
uv run --frozen pytest tests/unit_tests -q
```

The frozen sync uses the repository's committed lockfile. Installation requires internet access. These selected unit tests do not require provider credentials. The observed result was `3 passed`. They check model configuration precedence, not the behavior of a live agent.

Do not fill in `.env` merely to run this inspection. A real template run uses a model provider and the Tavily search service. Their API access and billing are separate from a chat or coding-assistant subscription. No live calls are necessary for the checks below.

## Trace the actual source paths

At the pinned revision, inspect these files in order:

| File | What to verify |
| --- | --- |
| [`langgraph.json`](https://github.com/langchain-ai/react-agent/blob/9bbd82d84905acc37f527b1f372dae841016f3b4/langgraph.json) | Graph ID `agent` points to `src/react_agent/graph.py:graph` |
| [`context.py`](https://github.com/langchain-ai/react-agent/blob/9bbd82d84905acc37f527b1f372dae841016f3b4/src/react_agent/context.py) | System prompt, provider/model string, search limit and environment overrides |
| [`graph.py`](https://github.com/langchain-ai/react-agent/blob/9bbd82d84905acc37f527b1f372dae841016f3b4/src/react_agent/graph.py) | Model call, `route_model_output` router, tools/completion edges and last-step behavior |
| [`tools.py`](https://github.com/langchain-ai/react-agent/blob/9bbd82d84905acc37f527b1f372dae841016f3b4/src/react_agent/tools.py) | The `search` tool constructs a Tavily client when invoked |
| [`state.py`](https://github.com/langchain-ai/react-agent/blob/9bbd82d84905acc37f527b1f372dae841016f3b4/src/react_agent/state.py) | Message accumulation and the managed last-step flag |

The graph starts at `call_model`. A model result containing tool calls routes to the tools node, then back to the model. A result without tool calls routes to the end. If the model requests another tool on the last available step, the node returns a stopping message without that tool request.

That is a useful loop to adapt, but it contains no ticket approval record, owner policy or stale-version check. The graph is compiled without an explicit checkpointer in this file. A hosted runtime can add its own persistence behavior. Inspecting this source alone does not establish what survives a deployed worker restart.

## Run the credential-free probe

Download and extract the [starter inspection probe](/downloads/agent-course/starter-inspection-v1.zip) outside the cloned repository. From the clone, invoke it with the clone's Python environment, substituting its actual file path:

```bash
uv run --frozen python /path/to/inspect_react_starter.py --checkout .
```

The script checks the Git revision before importing the starter. It replaces the node's model loader with a fake model and clears inherited provider/tracing settings for the probe. It does not execute the compiled graph, instantiate a live model adapter or call the Tavily tool.

Its six observations are:

| Case | Observed result |
| --- | --- |
| Assistant answer without tool calls | Routes to `__end__` |
| Assistant result with a tool call | Routes to `tools` |
| Human message passed to the output router | Rejected with `ValueError` |
| Ordinary node step with a requested tool | Returns one tool call |
| Last node step with a requested tool | Returns no tool calls |
| `MAX_SEARCH_RESULTS=7` environment override | Context stores the string `"7"`, not the integer `7` |

The final row is a configuration limitation, not a claim that Tavily necessarily fails: a downstream client may coerce the value. It shows that the context object itself does not enforce the annotated integer type. If your application depends on a bounded numeric setting, parse and validate it at that boundary and add a test for invalid values.

The README also names inconsistent default model examples. At this revision the source default is `anthropic/claude-sonnet-4-5-20250929`, while another README section still refers to Claude 3 Sonnet. That source observation is not a recommendation to use either model today. Select a currently supported model deliberately before a live run.

## Inspect the two web starters differently

The [Agent Chat UI README at the inspected revision](https://github.com/langchain-ai/agent-chat-ui/blob/41926d89c9798cebe45a26886d6e437acc5201c1/README.md) documents `pnpm install` and `pnpm dev`, then configuration of the deployment URL and assistant/graph ID. Those commands start the interface. They do not create an agent backend.

Its production guidance also matters: putting a server-side LangSmith key behind the supplied API passthrough does not authenticate the people calling that proxy. Follow the repository's custom-authentication guidance before exposing it. The lesson did not deploy or test that production path, and no user key was entered into its public demo.

The [Vercel Chatbot README at its inspected revision](https://github.com/vercel/chatbot/blob/c2f8235e1f3ea903ad8b7f61447c4f74164b5c58/README.md) documents environment setup, `pnpm install`, a database migration and `pnpm dev`. It includes Auth.js, Neon Postgres and Vercel Blob integrations, with AI Gateway used for model access. Those are capabilities and operational dependencies to assess together. This comparison inspected its source documentation and license. It did not provision services or execute its migrations.

## Make the adoption decision concrete

For the ticket course, the backend template's value is its visible graph and model adapter boundary. The missing application work is equally concrete: replace the web-search tool with a scoped ticket capability, validate input, retain the [approval lifecycle](/blog/how-to-build-ai-agent-human-in-loop-approval), and run the [evaluation cases](/blog/evaluate-ai-agent-performance-reliability) before a live integration.

As a failure exercise, change the probe's expected revision to a different string in a disposable copy. It should refuse before importing the graph. Then inspect the environment override result and write the exact validation rule your application needs. Keep those findings in an adoption record beside the commit, setup command and test output.

A starter inspection should end with a supported decision and an explicit work list. “It installed” is only the first observation. Continue with the [Copilot coding exercise](/blog/how-to-use-github-copilot-to-write-code-faster) to practice reviewing a small assistant-generated change against known behavior. The [course index](/blog/pillar/agents-and-ai-engineering#agent-course-heading) links the full sequence.

## Related Guides

- [Agent Evaluation Tools: Compare Five Options on One Ticket Task](/blog/best-ai-agent-testing-and-evaluation-tools)
- [Use Cursor to Build a Ticket Approval Interface You Can Test](/blog/how-to-use-cursor-ai-to-build-web-applications)
- [Agent Design Patterns: Run Four Control Flows and Their Failures](/blog/ai-agent-design-patterns-production-systems)
- [AI APIs for Beginners: Make a Request and Handle the Response](/blog/complete-guide-ai-apis-beginners)

## Continue the course

Lesson 13 of 17.

Previous lesson: [Agent Design Patterns: Run Four Control Flows and Their Failures](https://www.zarifautomates.com/blog/ai-agent-design-patterns-production-systems.md).

Next lesson: [Use GitHub Copilot to Fix a Stale-Delete Bug You Can Verify](https://www.zarifautomates.com/blog/how-to-use-github-copilot-to-write-code-faster.md).

[Browse available lessons](https://www.zarifautomates.com/blog/pillar/agents-and-ai-engineering#agent-course-heading).