# AgentDock: Building AI Agents with Configurable Determinism

> AgentDock is an open-source TypeScript framework for building AI agents around a node-based architecture, with a design philosophy it calls configurable determinism. It separates a backend-agnostic core library from a Next.js reference application, letting teams control exactly how much of their workflow relies on LLM inference.

**AgentDock/AgentDock** — Build Anything with AI Agents

- Repository: https://github.com/AgentDock/AgentDock
- Website: https://agentdock.ai
- Stars: 1,762 · Forks: 132
- Language: MDX
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/agentdock-agentdock

## The Problem AgentDock Targets

Standard LLM inference is non-deterministic: the same prompt can return different outputs on different calls. That property is fine for creative tasks but problematic for workflows that require predictable, auditable behavior. Most agent frameworks either accept full non-determinism or force fully scripted pipelines that cannot adapt.

AgentDock addresses this with configurable determinism. Developers can mark specific steps in a workflow as fixed execution paths, while leaving other steps to LLM reasoning. A workflow that always queries a database in step one, then uses an LLM to interpret results in step two, then always formats output in step three, achieves most of the adaptability of an AI agent while keeping the entry and exit points reliable. The framework is built in TypeScript and emphasizes type safety throughout the codebase.

## Two-Part Architecture: Core and Client

AgentDock ships as two distinct components. AgentDock Core is the open-source backend framework. It is designed to be framework-agnostic and provider-independent, meaning you are not locked into a specific LLM provider or deployment platform. The core handles agent logic, tool execution, and the node-based workflow engine.

The Open Source Client is a complete Next.js application that acts as a reference implementation and a consumer of AgentDock Core. It is available at hub.agentdock.ai. The client is useful for teams who want a working starting point rather than building a frontend from scratch, but using it is not a requirement for working with the core.

This separation matters in practice. A team that already has a React application can pull in AgentDock Core as a backend library without adopting the Next.js structure. A team starting from scratch can use both components together and have a working agent UI quickly.

## Node-Based Architecture and Tool System

Every capability in AgentDock is implemented as a node. The framework distinguishes between AgentNodes, which wrap LLM inference calls, and tool nodes, which are specialized nodes that agents can invoke during reasoning. The demo agents in the repository illustrate how this looks in practice.

The Dr. Gregory House demo agent orchestrates search, deep_research, and pubmed tool nodes in a multi-stage workflow for medical case analysis. The Cognitive Reasoner agent coordinates seven cognitive tool nodes: search, think, reflect, compare, critique, brainstorm, and debate. The Calorie Vision agent combines computer vision with structured data extraction. Each demo shows a different composition of nodes into a complete behavior.

Tools are defined as specialized nodes in the same system, which means the same composition model applies to both workflow steps and the capabilities available to LLM calls. Adding a new tool means registering it as a node; it then becomes available to any agent that declares it in its configuration.

## Setting Up AgentDock Locally

AgentDock requires Node 20.11.0 or higher and pnpm 9.15.0 or higher. The repository enforces these versions via the engines field in package.json.

Clone the repository and install dependencies:

```bash
git clone https://github.com/AgentDock/AgentDock.git
cd AgentDock
pnpm install
```

Copy the environment template and configure at minimum a storage provider:

```bash
cp .env.example .env.local
```

The default storage provider is in-memory (no persistence). For local development with persistence, set KV_STORE_PROVIDER=sqlite in .env.local, which enables automatic SQLite storage. For a Redis-backed setup, start the local Redis stack first:

```bash
docker compose up -d
```

The docker-compose.yaml starts a Redis container on port 6380 and a redis-http-proxy on port 8079. Set KV_STORE_PROVIDER=redis and configure REDIS_URL=http://localhost:8079 and SRH_TOKEN=test_token. Then run the development server:

```bash
pnpm dev
```

The postinstall script builds the AgentDock Core package automatically, so you do not need a separate build step on first install.

## Limitations and Cases Where AgentDock Is the Wrong Tool

AgentDock is TypeScript-only. Python teams have no native path into the framework without a significant rewrite or a wrapper service.

The repository's latest stable release is framework-final, tagged on 2026-09-15. The version number in package.json is 0.1.0, which reflects that the project is pre-1.0 and API stability is not guaranteed. The primary language reported for the repository is MDX, which means documentation content makes up a large portion of the codebase. The ratio of documentation to framework code is not immediately clear from the surface structure.

For teams whose agent needs are simple, such as a single tool call followed by an LLM summary, the overhead of a full Next.js application and a node-based framework is hard to justify. A lighter alternative is LangChain.js, which provides tool-calling and chain composition in TypeScript without requiring a specific frontend application. The difference in approach is that LangChain.js is a library you compose freely, while AgentDock imposes a node architecture that trades flexibility for a more structured determinism model.

AgentDock Pro, a cloud platform version with visual workflow builders and enterprise infrastructure, is listed in the README as coming soon. The hosted version is not yet available.

## Supported Storage Backends and Environment Configuration

The KV_STORE_PROVIDER environment variable controls where AgentDock stores session and agent state. The documented options are memory (default, no persistence), redis (local or Upstash-compatible), vercel-kv (Redis under the hood on Vercel deployments), sqlite (auto-enabled in development when the variable is not set), and postgresql (auto-enabled when DATABASE_URL is set).

For production deployments on Vercel, setting KV_STORE_PROVIDER=vercel-kv and connecting a Vercel KV integration causes the required environment variables to be injected automatically. The .env.example in the repository covers each provider with inline comments on which variables apply to which mode, making it easier to configure without reading separate documentation.

LLM provider keys go into a separate section of the environment file. The framework is provider-independent by design, so the set of LLM providers it supports depends on the adapters registered in the core package rather than on hardcoded API client choices.

## Maintenance Status and License

The last push to the AgentDock repository was on 2026-07-14. A release tagged framework-final was published on 2026-09-15. The project is licensed under MIT.

The repository includes Husky for pre-commit hooks, a jest test suite with coverage scripts, and Prettier and ESLint configurations. A SECURITY.md and a CODE_OF_CONDUCT.md are present, which is consistent with a project that expects external contributors. A CONTRIBUTING.md documents the contribution process.

The README links to an AI Agents Book at agentdock.ai/docs/ai-agents-book, described as a guide covering agent fundamentals to enterprise deployment patterns. The README also mentions a prompt library under development. Both are hosted at agentdock.ai rather than in the open-source repository itself.

## Conclusion

AgentDock suits TypeScript teams building production-grade AI agents who need fine-grained control over which parts of a workflow use LLM inference and which run deterministically. Teams with Python stacks, simpler automation needs, or a preference for a managed cloud service will find the overhead of a full Next.js application and the current beta-stage v3 release a poor fit. Before adopting it, verify that pnpm 9+ is acceptable in your environment and check the framework-final release notes against your agent's specific requirements.

## FAQ

### What is configurable determinism in AgentDock?

Configurable determinism is AgentDock's design principle for controlling how predictable an agent's behavior is. Developers can define specific workflow steps as fixed execution paths while leaving other steps to LLM reasoning, giving fine-grained control over where non-determinism is acceptable and where it is not.

### Does AgentDock support multiple LLM providers?

AgentDock Core is described in the README as provider-independent, meaning it is not locked into a specific LLM provider. The framework handles provider selection through its node architecture, but the README does not list the specific providers supported in the current release.

### Can I use AgentDock Core without the Next.js client application?

Yes. AgentDock Core is a standalone backend library. The Open Source Client is a reference implementation and consumer of that core, but using it is not required. Teams with existing frontends can integrate AgentDock Core as a backend dependency directly.

## Sources

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