# agent-inbox: Inbox UI for LangGraph Human-in-the-Loop Agents

> agent-inbox is an archived Next.js application that provides a review interface for LangGraph agents paused at human-in-the-loop interrupts. Reviewers see a list of pending agent requests and can accept, edit, respond to, or ignore each one. A hosted version is available at dev.agentinbox.ai.

**langchain-ai/agent-inbox** — 📥 An inbox UX for interacting with human-in-the-loop agents.

- Repository: https://github.com/langchain-ai/agent-inbox
- Website: https://dev.agentinbox.ai
- Stars: 1,093 · Forks: 156
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/langchain-ai-agent-inbox

## What agent-inbox Does and Its Archived Status

LangGraph supports human-in-the-loop patterns by pausing a running graph at a designated node and waiting for an external input before resuming. Without a UI, handling these pauses requires polling the LangGraph API directly and constructing responses by hand.

agent-inbox provides a visual inbox where each pending interrupt appears as a card showing the action requested, its arguments, and a description. A reviewer can accept the request, edit the arguments, respond with a free-form message, or ignore it. The response is sent back to the paused graph, which resumes from that point.

The repository is archived. The last push was on 2026-09-18, but the repository is marked archived on GitHub, which means the langchain-ai team is not accepting new contributions. The hosted version at dev.agentinbox.ai remains available for users who do not want to run their own instance.

## Prerequisites and Installation

The README lists three prerequisites: Node.js and Yarn installed on the host, a running LangGraph deployment (local or on LangGraph Platform), and a LangGraph API key.

To run a self-hosted instance:

```bash
git clone https://github.com/langchain-ai/agent-inbox.git
cd agent-inbox
yarn install
```

The package.json dev script starts a Next.js development server:

```bash
yarn dev
```

This starts the Next.js application on the default port. The README does not document a production build process beyond the Next.js standard build step (yarn build followed by yarn start).

Settings such as the LangSmith API key and inbox connection details are entered through the application's settings UI rather than environment variables, and they are stored in the browser's local storage. The README states these values are used only to connect and authenticate requests to the LangGraph deployment.

## Connecting to a LangGraph Deployment

After entering the LangSmith API key in settings, the first step is creating an inbox. The settings popover at the bottom left of the sidebar has an Add Inbox option that opens a dialog with three fields:

- Assistant/Graph ID: the name of the LangGraph graph or an assistant ID, used when sending human responses back to the graph.
- Deployment URL: the URL of the LangGraph deployment the inbox will connect to.
- Name: an optional label for the inbox in the sidebar.

These fields are stored in local storage. Multiple inboxes can be created pointing to different graphs or deployments. The README notes that all data is stored in the browser and is not sent anywhere beyond the configured LangGraph deployment.

## The HumanInterrupt Schema

agent-inbox expects LangGraph agents to pause using a specific interrupt schema. The README provides TypedDict definitions for Python and TypeScript interfaces. The Python version:

```python
class HumanInterruptConfig(TypedDict):
    allow_ignore: bool
    allow_respond: bool
    allow_edit: bool
    allow_accept: bool

class ActionRequest(TypedDict):
    action: str
    args: dict

class HumanInterrupt(TypedDict):
    action_request: ActionRequest
    config: HumanInterruptConfig
    description: Optional[str]

class HumanResponse(TypedDict):
    type: Literal['accept', 'ignore', 'response', 'edit']
    args: Union[None, str, ActionRequest]
```

The action_request field carries the name of the action and its arguments, for example a tool call name and its parameters. The config field controls which response buttons appear in the inbox: setting allow_accept to False hides the Accept button for that interrupt. The description field is rendered as markdown in the inbox UI and is used for additional context or instructions to the reviewer.

Existing LangGraph code using NodeInterrupt must be migrated to the interrupt function to work with agent-inbox.

## The Four Response Types

agent-inbox returns exactly one HumanResponse per interrupt, inside a list. Four response types are supported:

- accept: The reviewer approves the action without changes. The response args field contains the original ActionRequest with all argument values converted to strings.
- edit: The reviewer modifies the arguments. The response args field contains the ActionRequest with the edited string values.
- response: The reviewer sends a free-form message. The args field is a single string.
- ignore: The reviewer dismisses the interrupt without action. The args field is null.

The allow_* flags in the HumanInterruptConfig control which of these appear as options for a given interrupt. A tool-call approval flow that should not allow free-form responses sets allow_respond to False. An informational interrupt that cannot be edited sets allow_edit to False.

## Using the interrupt Function in LangGraph

To connect an existing LangGraph node to agent-inbox, replace NodeInterrupt with the interrupt function and pass a HumanInterrupt instance:

```python
from langgraph.types import interrupt

def my_graph_function(state: MyGraphState):
    tool_call = state["messages"][-1].tool_calls[0]
    request: HumanInterrupt = {
        "action_request": {
            "action": tool_call['name'],
            "args": tool_call['args']
        },
        "config": {
            "allow_ignore": True,
            "allow_r
```

The README shows this pattern for surfacing tool calls as reviewable interrupts. The response comes back as a HumanResponse object from the interrupt call's return value, which the graph node can then route based on the response type.

## Limitations and Archived Status

The repository is archived. No new features, bug fixes, or pull requests will be merged. Teams that need a maintained human-in-the-loop review interface should evaluate whether to fork agent-inbox or build against the LangGraph interrupt API directly.

Configuration data is stored only in the browser's local storage, which means it is per-browser and not shared across team members or devices. Clearing browser data removes all inbox configurations.

The LangGraph Python and TypeScript example repositories linked in the README (agent-inbox-langgraph-example and agent-inbox-langgraphjs-example) provide minimal working agents that demonstrate the correct interrupt schema usage.

The project is licensed under the MIT License.

## Conclusion

agent-inbox is suitable for teams building LangGraph workflows that pause for human review and need a structured interface for handling those pauses beyond a raw API. The repository is archived, so teams adopting it should expect no further maintenance and plan to fork or replace it over time. Before deploying a self-hosted instance, verify that your LangGraph deployment URL and API key are correct and test the interrupt schema against the TypedDict definitions the README specifies, since schema mismatches produce silent failures rather than error messages.

## FAQ

### What is agent-inbox?

agent-inbox is an archived Next.js application that provides an inbox-style UI for reviewing and responding to human-in-the-loop interrupts from LangGraph agents. Reviewers can accept, edit, respond to, or ignore each pending agent request. A hosted version is available at dev.agentinbox.ai.

### Does agent-inbox work with non-LangGraph agents?

The README describes agent-inbox as designed specifically for LangGraph deployments. It connects to the LangGraph API to fetch pending interrupts and send human responses. The README does not document support for other agent frameworks.

### Is agent-inbox still receiving updates?

The repository is archived on GitHub as of the time of writing, which means no new pull requests or issues are being accepted. The last push was on 2026-09-18. The hosted version at dev.agentinbox.ai continues to operate, but the self-hosted code should be treated as frozen.

## Sources

- [Issues](https://github.com/langchain-ai/agent-inbox/issues)
- [langchain-ai/agent-inbox on GitHub](https://github.com/langchain-ai/agent-inbox)
- [License: MIT](https://github.com/langchain-ai/agent-inbox/blob/main/LICENSE)
- [Project website](https://dev.agentinbox.ai)
- [README](https://github.com/langchain-ai/agent-inbox/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/langchain-ai-agent-inbox