AgenticSeek: A Fully Local, Privacy-First Alternative to Manus AI

What AgenticSeek Solves: Local Autonomy Without Cloud APIs

AgenticSeek addresses the cost and privacy problem with cloud-based autonomous agents. The README positions it as a 100% local alternative to Manus AI: an agent that browses the web, writes and debugs code in Python, C, Go, Java, and other languages, fills web forms, extracts information from pages, and plans multi-step tasks, all without sending data to an external API. The only infrastructure requirement beyond a workstation GPU is Docker, used for the SearxNG search service and Redis.

The primary audience is developers who either cannot afford the subscription cost of cloud AI agents or who need the assurance that files, conversations, and web searches stay on their own machine. The README notes that API keys for OpenAI, DeepSeek, Google, Anthropic, and Together are accepted as optional inputs for users whose hardware cannot run local models, which means AgenticSeek can also run as an API-routing layer rather than a fully local stack.

Agent Routing: How the System Selects the Right Agent

AgenticSeek's core design decision is automatic agent selection. Rather than requiring the user to specify which agent handles a request, the system analyzes the prompt and routes it to the most appropriate agent internally. The README describes this as like having a team of experts: you ask, and the system determines who does the work. The agents available cover web browsing, code generation and execution, and multi-step task planning that can break a large request into sub-tasks distributed across multiple agents.

Voice input is listed as a feature in progress. The README describes it as clean, fast, and futuristic with speech-to-text capability, but explicitly marks it as in progress rather than complete. The web interface front end listens on port 3000, and the backend API runs on port 7777 by default.

Setting Up AgenticSeek: Docker and Environment Configuration

The setup requires Git, Python 3.10.x specifically (the README warns that other versions lead to dependency errors), and Docker with Docker Compose V2. After cloning the repository and copying the example environment file:

git clone https://github.com/Fosowl/agenticSeek.git
cd agenticSeek
mv .env.example .env

Open the `.env` file and update the values for your environment. The key variables are:

SEARXNG_BASE_URL="http://searxng:8080"
SEARXNG_PORT=8080
REDIS_BASE_URL="redis://redis:6379/0"
WORK_DIR="/Users/mlg/Documents/workspace_for_ai"
OLLAMA_PORT="11434"

`WORK_DIR` is the directory on your local machine that AgenticSeek can read and interact with. The `SEARXNG_BASE_URL` value depends on whether you are running the backend inside Docker or on the host. For the full Docker mode (`./start_services.sh full`), use `http://searxng:8080`. For CLI mode on the host (`uv run cli.py`), use `http://localhost:8080`.

Before starting services, verify Docker is running:

sudo systemctl start docker

Then confirm it is up:

docker info

A response showing Docker installation details confirms the daemon is ready. API keys in the `.env` file are entirely optional for users running a local LLM; the README states that local operation is the primary purpose.

Local LLM Providers and Hardware Requirements

AgenticSeek supports Ollama, LM Studio, and a custom additional LLM port, along with optional API access to OpenAI, DeepSeek, OpenRouter, Together, Google, and Anthropic. The primary design assumption is that users run Ollama locally. The `config.ini` file at the repository root controls provider selection and model configuration.

The README states that at a minimum, a GPU capable of running Magistral, Qwen, or DeepSeek at 14B parameters is required. The `pyproject.toml` shows a dependency on `ollama>=0.4.7` and `openai>=1.84.0`, along with Selenium and undetected-chromedriver for web browsing, Kokoro for text-to-speech, and PyAudio for voice input. The `requirements.txt` includes `vosk>=0.3.45` for speech recognition. The full dependency set is large: `torch>=2.4.1`, `transformers>=4.46.3`, and `scipy>=1.9.3` are all present, meaning the install takes significant disk space and time even on a fast connection.

CLI Mode Versus the Web Interface

AgenticSeek supports two operation modes. The web interface mode uses Docker Compose to run SearxNG, Redis, the React frontend (port 3000), and optionally the backend container (port 7777). The `./start_services.sh full` command starts all services including the backend inside Docker. The CLI mode runs the backend directly on the host with `uv run cli.py` and requires SearxNG to be reachable at `http://localhost:<SEARXNG_PORT>` rather than the Docker-internal hostname.

The distinction matters for `SEARXNG_BASE_URL`. Inside Docker, the SearxNG container is known as `searxng` on the internal network. On the host, it is only reachable via `localhost` and the published port. Getting this wrong is a common setup failure; the README includes a table listing the correct value for each mode.

Limitations of an Early-Stage Side Project

The README is unusually candid about the project's state. The author describes AgenticSeek as a side project that grew beyond expectations after appearing on GitHub Trending, notes that it has zero roadmap and zero funding, and asks for contributions, feedback, and patience. This is not marketing language; it accurately describes the risk profile for anyone evaluating it for anything beyond personal experimentation.

Python 3.10.x is a hard constraint. The README says using other versions might lead to dependency errors; the `.python-version` file and the `pyproject.toml` `requires-python = ">=3.10"` field both reflect this. The Kokoro text-to-speech dependency requires Python older than 3.12 according to the `requirements.txt` comment. Teams running a Python 3.11 or 3.12 environment will need a separate virtual environment.

The web browsing component uses Selenium, undetected-chromedriver, and chromedriver-autoinstaller, which means browser automation can break when Chrome releases a new version. There is no documented version pinning for the browser driver.

AgenticSeek Versus Cloud-Hosted Autonomous Agents

Manus AI, which the README names directly as the reference for comparison, is a cloud-hosted service with no self-hostable version. AgenticSeek differs in every infrastructure dimension: it runs locally, stores nothing remotely, and requires the user to supply and maintain the underlying LLM. The trade-off is that cloud agents benefit from more capable, larger models and managed infrastructure, while AgenticSeek's capability ceiling is set by the local hardware.

Compared to running a local LLM directly in Ollama with a custom script, AgenticSeek adds the agent routing layer, the SearxNG web search integration, and the browser automation, at the cost of a more complex setup with Docker Compose, a specific Python version requirement, and a large dependency footprint. The GPL-3.0 license means any modifications to the source must also be released under GPL-3.0 when distributed.

Editorial conclusion

AgenticSeek is the right choice for developers who want to run an autonomous web-browsing and code-executing agent entirely on local hardware, value privacy above polish, and have a GPU capable of running at least a 14B-parameter model. It is the wrong choice for anyone who needs production stability, a documented upgrade path, or support for Python versions other than 3.10.x. Before committing to a local deployment, verify that your GPU can sustain inference on Magistral, Qwen, or DeepSeek at 14B parameters, and test the `docker info` check to confirm the Docker daemon is running before attempting `start_services.sh`.

Frequently asked questions

Official sources

1. Fosowl/agenticSeek on GitHub
2. Issues
3. License: GPL-3.0
4. Project website
5. README