ProductDocsExamplesGitHubGet Started
Documentation

Build with Harness

Everything you need to turn DeepSeek into production-grade autonomous agents — from installation to advanced orchestration.

Quick Start

Install Harness, configure your first agent, and run an autonomous task in under 5 minutes.

Get started →

Core Concepts

Understand the agent runtime loop, memory management, tool calling, and the MCP protocol layer.

Learn concepts →

API Reference

Complete API documentation for the Harness class, tool registration, memory backends, and scheduling.

Browse API →

Example Projects

Production-ready examples — code fixer agent, file automation, MCP client, multi-task orchestration.

View examples →
Quick Start

Up and running in 3 steps

1

Install Harness

Install via pip or your preferred package manager.

$ pip install deepseek-harness
2

Set your API key

Configure your DeepSeek API key as an environment variable.

$ export DEEPSEEK_API_KEY=sk-...
3

Run your first agent

Create a Harness instance and run an autonomous task.

quickstart.py
from deepseek_harness import Harness

# 1. Create your agent
agent = Harness(
    model="deepseek-v4-flash",
    api_key="your-deepseek-api-key",
)

# 2. Register tools
agent.register_tool("read_file", read_file)
agent.register_tool("write_file", write_file)
agent.register_tool("run_command", run_command)

# 3. Run an autonomous task
result = agent.run(
    "Read main.py, identify bugs, fix them, and run the tests.",
    max_iterations=15,
    retry_on_failure=True,
)

print(result.summary)
print(f"Steps: {result.step_count}")
print(f"Tools used: {result.tools_called}")
Core Concepts

The four pillars of Harness

Understand the building blocks that power every Harness agent.

Agent Runtime Loop

The core execution cycle: receive task → decompose → call tool → validate result → iterate or complete. Harness manages this loop automatically, handling failures with retry and maintaining context across iterations.

agent.run("task", max_iterations=20)

Tool Calling

Register Python functions, shell commands, or MCP servers as agent tools. Harness validates inputs/outputs, handles timeouts, and routes tool calls through the model's function-calling interface.

agent.register_tool("search", my_search_fn)

Memory Management

Short-term buffer holds recent context; long-term store persists across sessions. Automatic pruning keeps you within token limits while semantic retrieval (RAG) recalls relevant past interactions.

agent.set_memory("long_term", backend="redis")

MCP Protocol

Model Context Protocol provides a standard interface for model-to-tool communication. Harness auto-discovers MCP servers, validates tool schemas, and manages resource subscriptions.

agent.register_mcp_server("fs", "./workspace")
FAQ

Frequently asked questions

What is the difference between Harness and LangChain?

LangChain is a general-purpose LLM framework with chains and prompts. Harness is a dedicated runtime specifically optimized for DeepSeek models — it provides a complete autonomous execution loop with built-in memory, retry, scheduling, and MCP protocol support. Think of Harness as the 'runtime engine' rather than a 'prompt library'.

Which DeepSeek models are supported?

Harness supports all DeepSeek model variants including deepseek-v4-flash, deepseek-v4-chat, deepseek-reasoner (R1), and deepseek-coder. The runtime automatically applies model-specific context optimizations and token management strategies.

Can I use Harness with non-DeepSeek models?

Yes. While Harness is optimized for DeepSeek, it includes an OpenAI-compatible adapter that works with any provider exposing an OpenAI-style API. However, DeepSeek-specific optimizations (context window tuning, inference acceleration) are only active with DeepSeek models.

Is Harness suitable for production deployment?

Absolutely. Harness is built for production from day one — it includes circuit breakers, dead letter queues, observability tracing, sandboxed tool execution, and deterministic replay. It is designed to run reliably in high-throughput, mission-critical environments.

How does the MCP protocol integration work?

Harness implements the Model Context Protocol as a first-class citizen. You register MCP servers (local or remote), and Harness automatically discovers their tools, validates schemas, and exposes them to the agent. Tool calls are routed through MCP's standardized interface with full type safety.

What are the system requirements?

Python 3.10+, pip, and an active DeepSeek API key. For production deployments, we recommend Redis (for memory) and PostgreSQL (for persistence), though both are optional — Harness works with in-memory defaults for development.

Ready to write your first agent?

Install Harness and ship your first DeepSeek agent today.

pip install deepseek-harness

# Or with all optional dependencies
pip install deepseek-harness[full]
Explore Examples