AgenticSeek: Running Manus AI Locally

Introduction

In an era where AI assistants are increasingly powerful but often require cloud connectivity and raise privacy concerns, AgenticSeek emerges as a compelling solution for users who want the capabilities of advanced AI tools like Manus AI while maintaining complete control over their data. This comprehensive tutorial will guide you through everything you need to know about setting up, configuring, and using AgenticSeek effectively.

AgenticSeek is a 100% local AI assistant that combines voice interaction, autonomous web browsing, code generation, and task planning capabilities. Unlike cloud-based alternatives, it runs entirely on your hardware, ensuring your conversations, files, and searches remain private. Whether you're a developer looking for a coding assistant, a researcher needing web automation, or simply someone who values privacy, this guide will help you harness the full potential of AgenticSeek.

What Makes AgenticSeek Special

Complete Privacy and Local Operation

The most significant advantage of AgenticSeek is its commitment to privacy. Every component—from the language model to speech recognition and text-to-speech—runs locally on your machine. This means:

• No data leaves your device
• No cloud dependency or internet requirements for core functionality
• Complete control over your AI interactions
• No subscription fees or API costs for local operation

Multi-Modal AI Capabilities

AgenticSeek isn't just a chatbot; it's a comprehensive AI system that can:

• Browse the web autonomously: Search, read articles, extract information, and even fill web forms
• Write and execute code: Generate programs in Python, Go, Java, C, and other languages
• Plan and execute complex tasks: Break down large projects into manageable steps using multiple specialized agents
• Voice interaction: Natural speech-to-text and text-to-speech capabilities
• File management: Work with your local files and directories

Intelligent Agent Routing

One of AgenticSeek's standout features is its ability to automatically select the best agent for each task. When you make a request, the system analyzes your query and routes it to the most appropriate specialist agent, whether that's a web browsing agent, coding agent, or task planning agent.

Agenticseek's Github Repo:

GitHub - Fosowl/agenticSeek: Fully Local Manus AI. No APIs, No $200 monthly bills. Enjoy an autonomous agent that thinks, browses the web, and code for the sole cost of electricity.

Fully Local Manus AI. No APIs, No $200 monthly bills. Enjoy an autonomous agent that thinks, browses the web, and code for the sole cost of electricity. - Fosowl/agenticSeek

GitHubFosowl

Prerequisites and Hardware Requirements

Before diving into installation, it's crucial to understand the hardware requirements for running AgenticSeek effectively.

Minimum System Requirements

• Operating System: Linux, macOS, or Windows
• Python: Version 3.10 (specifically recommended)
• Chrome Browser: Latest version
• Docker: For running supporting services
• Memory: At least 16GB RAM recommended

LLM Hardware Requirements

The performance of AgenticSeek heavily depends on the language model you choose to run locally:

Recommended Models

AgenticSeek works best with reasoning-focused models like:

• Deepseek R1: Excellent for reasoning and tool use
• Qwen: Strong performance across various tasks
• Llama models: Good general-purpose performance

Installation Process

Step 1: Clone and Initial Setup

First, clone the AgenticSeek repository and set up the basic configuration:

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

Step 2: Create Virtual Environment

It's crucial to use Python 3.10 specifically to avoid dependency conflicts:

python3 -m venv agentic_seek_env
source agentic_seek_env/bin/activate
# On Windows: agentic_seek_env\Scripts\activate

Step 3: Install Dependencies

For Linux/macOS (Automatic Installation):

./install.sh

For Windows:

./install.bat

Manual Installation (if automatic fails):

Linux:

sudo apt update
sudo apt install -y alsa-utils portaudio19-dev python3-pyaudio libgtk-3-dev libnotify-dev libgconf-2-4 libnss3 libxss1
sudo apt install -y chromium-chromedriver
pip3 install -r requirements.txt

macOS:

brew update
brew install --cask chromedriver
brew install portaudio
python3 -m pip install --upgrade pip
pip3 install --upgrade setuptools wheel
pip3 install -r requirements.txt

Windows:

pip install pyreadline3
pip install pyaudio
pip3 install -r requirements.txt

Note: For Windows, you'll need to manually download ChromeDriver from the official Chrome website and add it to your PATH.

Step 4: Set Up Local LLM Provider

The most popular choice is Ollama for its ease of use:

# Install and start Ollama
ollama serve

# Pull a recommended model
ollama pull deepseek-r1:14b  # Adjust size based on your hardware

Configuration Setup

Understanding config.ini

The heart of AgenticSeek's configuration lies in the config.ini file. Here's a detailed breakdown of each setting:

[MAIN]
is_local = True
provider_name = ollama
provider_model = deepseek-r1:14b
provider_server_address = 127.0.0.1:11434
agent_name = Jarvis
recover_last_session = True
save_session = True
speak = True
listen = False
work_dir = /Users/yourname/Documents/ai_workspace
jarvis_personality = False
languages = en zh

[BROWSER]
headless_browser = True
stealth_mode = True

Key Configuration Options Explained

Core Settings:

• is_local: Set to True for local operation, False for API providers
• provider_name: Choose from ollama, lm-studio, openai, etc.
• provider_model: The specific model to use (e.g., deepseek-r1:14b)
• work_dir: Directory where AgenticSeek can read/write files

Personality and Interaction:

• agent_name: Name for your AI assistant (used as wake word for voice)
• speak: Enable text-to-speech output
• listen: Enable speech-to-text input (CLI only)
• jarvis_personality: Use a more conversational, Jarvis-like personality

Browser Settings:

• headless_browser: Run browser without visible window (recommended for web interface)
• stealth_mode: Use undetected Selenium to avoid bot detection

Setting Up Your Workspace

Choose a dedicated directory for AgenticSeek to work in. This should be a location where you're comfortable having the AI create, modify, and organize files:

mkdir ~/Documents/agentic_workspace

Update your config.ini with this path:

work_dir = /Users/yourname/Documents/agentic_workspace

Getting Started: First Run

Starting the Services

Before running AgenticSeek, you need to start the supporting services:

# Activate your virtual environment
source agentic_seek_env/bin/activate

# Start services (SearxNG for web search, Redis, frontend)
sudo ./start_services.sh  # Linux/macOS
# or
start_services.cmd  # Windows

Option 1: Command Line Interface (CLI)

The CLI interface is perfect for users who prefer terminal-based interaction:

python3 cli.py

Recommended CLI Settings:

• Set headless_browser = False in config.ini to see browser actions
• Set speak = True for voice responses
• Set listen = True if you want voice input

Option 2: Web Interface

For a more visual experience, use the web interface:

# Start the backend
python3 api.py

Then open your browser and navigate to http://localhost:3000/

Recommended Web Interface Settings:

• Set headless_browser = True for better performance
• Keep speak = False unless you want audio in your browser

Understanding AgenticSeek's Capabilities

Web Browsing and Research

AgenticSeek can autonomously browse the internet to gather information. Here are examples of effective queries:

Good query: "Search the web for the top 10 programming languages in 2024 and save a summary to programming_trends.txt"

Avoid: "What are popular programming languages?" (too vague, doesn't indicate web search needed)

The AI can:

• Search using SearxNG (privacy-focused search engine)
• Navigate websites and extract information
• Fill out web forms (experimental feature)
• Download and save content

Code Generation and Execution

AgenticSeek excels at writing and running code in multiple languages:

Example requests:

• "Write a Python script to analyze CSV data and create visualizations"
• "Create a Go program that implements a REST API server"
• "Write a C program to sort an array using quicksort algorithm"

The AI will:

• Generate complete, runnable code
• Add necessary imports and dependencies
• Test the code and fix basic errors
• Save files in your designated workspace

Task Planning and Execution

For complex tasks, AgenticSeek can break them down into manageable steps:

Example: "Plan a weekend trip to Paris, including flights, hotels, and activities. Research options and save recommendations to paris_trip.txt"

The AI will:

1. Research flight options
2. Find hotel recommendations
3. Discover popular activities and restaurants
4. Compile everything into an organized document

File Management

AgenticSeek can work with your local files:

• Read and analyze documents
• Organize and rename files
• Create new files and directories
• Process data from existing files

Advanced Features

Voice Interaction

To enable voice features, configure these settings:

speak = True  # Enable text-to-speech
listen = True  # Enable speech-to-text (CLI only)
agent_name = Friday  # Wake word for voice activation

Using Voice Commands:

1. Say the agent's name (e.g., "Friday")
2. Wait for the transcript to appear
3. Speak your request clearly
4. End with a confirmation phrase like "do it," "go ahead," or "execute"

Supported confirmation phrases:

• "do it"
• "go ahead"
• "execute"
• "run"
• "start"
• "thanks"
• "please"
• "proceed"

Multi-Language Support

AgenticSeek supports multiple languages for text-to-speech:

languages = en zh fr es  # English, Chinese, French, Spanish

The first language in the list becomes the default for text-to-speech.

Session Management

Control how AgenticSeek handles conversation history:

recover_last_session = True  # Resume previous conversation
save_session = True  # Remember current conversation

This is particularly useful for long-running projects or when you need to continue work across multiple sessions.

Effective Usage Patterns

Best Practices for Queries

Be Specific About Actions:

• Instead of: "Tell me about Python"
• Use: "Search the web for Python tutorials and save the top 5 links to python_resources.txt"

Specify File Operations:

• "Save the results to filename.txt"
• "Create a new directory called project_name"
• "Read the data from existing_file.csv and analyze it"

Web Search Indicators:

• Always mention "search the web" or "browse the internet" when you want online research
• Be specific about what information you're looking for

Optimal Workflow Examples

Research Project:

1. "Search the web for recent AI developments in 2024"
2. "Summarize the findings and save to ai_developments_2024.txt"
3. "Create a Python script to visualize the trends mentioned in the summary"

Development Task:

1. "Create a new Python project structure for a web scraper"
2. "Write the main scraping module using BeautifulSoup"
3. "Add error handling and logging to the scraper"
4. "Write unit tests for the scraping functions"

Data Analysis:

1. "Read the sales_data.csv file in my workspace"
2. "Analyze the data for trends and patterns"
3. "Create visualizations showing monthly sales trends"
4. "Generate a report with insights and save as sales_analysis.txt"

Troubleshooting Common Issues

ChromeDriver Problems

Error: Version mismatch between Chrome and ChromeDriver

Solution:

1. Check your Chrome version: google-chrome --version
2. Download matching ChromeDriver from https://developer.chrome.com/docs/chromedriver/downloads
3. Replace the existing ChromeDriver with the new version

Connection Issues

Error: "No connection adapters were found"

Solution: Ensure your provider address includes the protocol:

provider_server_address = http://127.0.0.1:11434

SearxNG Base URL Error

Solution: Ensure you've renamed .env.example to .env, or export the environment variable:

export SEARXNG_BASE_URL="http://127.0.0.1:8080"

Performance Issues

Poor AI Performance:

• Use larger models (32B+ if possible)
• Ensure sufficient VRAM/RAM
• Check that your LLM provider is running properly

Slow Web Browsing:

• Enable stealth_mode for better compatibility
• Set headless_browser = True for faster operation
• Check your internet connection

Advanced Configuration Options

Using Different LLM Providers

Ollama Setup:

provider_name = ollama
provider_model = deepseek-r1:32b
provider_server_address = 127.0.0.1:11434

LM Studio Setup:

provider_name = lm-studio
provider_model = your-model-name
provider_server_address = http://127.0.0.1:1234

Remote Server Setup:
If you have a powerful server running the LLM:

provider_name = server
provider_model = deepseek-r1:70b
provider_server_address = your-server-ip:3333

API Provider Options

For users without sufficient hardware, API providers are available:

is_local = False
provider_name = deepseek
provider_model = deepseek-chat

Export your API key:

export DEEPSEEK_API_KEY="your-api-key-here"

Tips for Optimal Usage

Hardware Optimization

1. GPU Memory Management: Close unnecessary applications to free up VRAM
2. Model Selection: Start with smaller models and upgrade as needed
3. RAM Usage: Monitor system memory, especially with larger models

Query Optimization

1. Be Explicit: Always specify if you want web search, file operations, or code generation
2. Break Down Complex Tasks: For multi-step processes, provide clear step-by-step instructions
3. Use Specific File Names: Always specify exact file names and locations

Workflow Efficiency

1. Organize Your Workspace: Keep your work_dir organized with clear folder structures
2. Use Session Management: Enable session saving for long-running projects
3. Test Voice Commands: Practice voice commands in a quiet environment for better recognition

Conclusion

AgenticSeek represents a significant step forward in privacy-conscious AI assistance. By following this comprehensive guide, you should now have a fully functional local AI assistant capable of web browsing, code generation, task planning, and voice interaction—all while keeping your data completely private.

Remember that AgenticSeek is an evolving project. As you use it, you'll discover new capabilities and optimal usage patterns. The key to success is being specific in your requests, understanding the system's strengths, and taking advantage of its multi-agent architecture.

Whether you're using AgenticSeek for research, development, or general productivity tasks, its combination of privacy, capability, and local operation makes it a powerful alternative to cloud-based AI assistants. Start with simple tasks to familiarize yourself with the system, then gradually explore more complex workflows as you become comfortable with its capabilities.

The future of AI assistance is local, private, and under your complete control—and AgenticSeek is leading the way in making that future accessible to everyone.