Welcome to the World of Local-First AI
In an era where AI is increasingly centralized and cloud-dependent, the promise of a truly personal, private, and powerful digital assistant feels distant. What if your AI could run entirely on your machine, learning from your data without ever sending it to a remote server? What if you could customize its capabilities to fit your exact workflow? This is the core vision of the local-first AI movement, and OpenClaw Core is your gateway to building it. This guide will walk you through creating your first functional AI agent, right on your own computer, putting you in full control of your intelligent assistant’s destiny.
Why OpenClaw Core? The Agent-Centric Philosophy
Unlike monolithic AI applications, OpenClaw Core is built on an agent-centric architecture. Think of an agent not as a single, rigid program, but as a central reasoning engine that can orchestrate a variety of skills—like reading files, searching the web, or controlling software. The agent evaluates your request, decides which skills to use, and executes a plan to achieve your goal. This modularity is revolutionary. It means your agent can start simple and grow infinitely more capable over time, all while operating with the privacy and immediacy of local execution.
What You’ll Build
By the end of this tutorial, you will have a foundational local AI agent that can:
- Process natural language instructions from you.
- Analyze and summarize text documents from a folder on your computer.
- Maintain a persistent memory of your interactions in a local database.
- Operate completely offline, using a local Large Language Model (LLM).
You’ll gain hands-on understanding of the key components that make an OpenClaw agent tick.
Prerequisites and Setup
Before we dive into the code, let’s ensure your environment is ready. You’ll need a few key tools installed.
1. Install Python and Git
OpenClaw Core is a Python framework. Ensure you have Python 3.10 or later installed. You’ll also need Git for cloning the repository. Package management is handled via UV or pip for optimal dependency resolution.
2. Choose and Prepare Your Local LLM
The “brain” of your agent is a local LLM. This is the most critical component for a true local-first experience. We recommend starting with a mid-sized, capable model like Llama 3.1 8B or Mistral 7B.
- Option A (Recommended for Beginners): Use Ollama. It simplifies downloading and running models. Install Ollama, then in your terminal run:
ollama run llama3.1:8bto pull and start the model server. - Option B (For More Control): Use LM Studio or llama.cpp. These offer advanced settings and GUI interfaces for loading GGUF model files.
Your LLM will run as a local server, typically on http://localhost:11434 (for Ollama) or a similar port. Your OpenClaw agent will connect to this.
3. Clone and Configure OpenClaw Core
Open a terminal and clone the main repository:
git clone https://github.com/openclaw-ai/openclaw-core.git
cd openclaw-core
Create a virtual environment and install the core package in development mode:
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
pip install -e .
Step-by-Step: Architecting Your First Agent
Now, let’s build. We’ll create a new Python file, my_first_agent.py, and construct our agent piece by piece.
Step 1: Import and Initialize the Core Agent
We start by importing the essential classes and creating the agent instance. The OpenClawAgent is the central coordinator.
from openclaw.core.agent import OpenClawAgent
from openclaw.core.memory import LocalMemory
from openclaw.core.skills.registry import SkillRegistry
# Initialize the agent with a name and a local LLM endpoint
agent = OpenClawAgent(
name="MyAssistant",
llm_config={
"model": "llama3.1:8b", # Must match your running local model
"base_url": "http://localhost:11434/v1", # Ollama endpoint
"api_key": "ollama", # Not needed for local LLMs typically
}
)
Step 2: Equip Your Agent with Skills
An agent without skills is like a brain without hands. We’ll register two essential built-in skills: FileReadSkill and SummarizeSkill.
from openclaw.skills.filesystem import FileReadSkill
from openclaw.skills.text import SummarizeSkill
# Register skills with the agent's skill registry
skills = SkillRegistry()
skills.register(FileReadSkill())
skills.register(SummarizeSkill())
agent.skills = skills
Skills are self-describing. The agent’s LLM can inspect their capabilities (like “read a file” or “summarize text”) and decide when to use them.
Step 3: Implement Local Memory
For your agent to have context across conversations, it needs memory. We’ll use a simple LocalMemory backend that stores conversation history in a SQLite database file in your project directory.
# Configure persistent local memory
agent.memory = LocalMemory(storage_path="./agent_memory.db")
agent.memory.initialize()
This memory will automatically save each interaction, allowing your agent to reference past discussions, creating a sense of continuity and personalization.
Step 4: Craft the Agent Execution Loop
This is the main interactive logic. We’ll create a simple loop that takes user input, has the agent process it, and displays the result.
print("MyAssistant is ready. Type 'quit' to exit.")
while True:
user_input = input("\nYou: ")
if user_input.lower() in ['quit', 'exit']:
break
# The agent processes the input using its LLM and available skills
response = agent.process(user_input)
print(f"\nMyAssistant: {response}")
The magic happens in agent.process(). Here, the agent:
- Analyzes your query using its local LLM.
- Plans which skills (if any) are needed to fulfill the request.
- Executes the skills, passing data between them.
- Formulates a final, coherent response based on the results.
Putting Your Agent to the Test
Run your script: python my_first_agent.py. Start with simple queries, then try complex ones that leverage the skills.
Example Interaction
You: “Hello, my name is Alex.”
Agent: “Hello Alex! Nice to meet you. How can I assist you today?” (This is stored in memory).
You: “Can you read and summarize the file ‘notes.txt’ in the ‘documents’ folder?”
Behind the scenes, the agent:
- Recognizes the need for the
FileReadSkill. - Executes it with the path
./documents/notes.txt. - Receives the text content, then recognizes the need for the
SummarizeSkill. - Executes the summarization on the retrieved text.
- Returns the summary to you.
Agent: “The file ‘notes.txt’ discusses the key principles of local-first AI, highlighting privacy, user sovereignty, and offline capability as its main advantages. It also mentions the OpenClaw framework as a primary tool for building such systems.”
You’ve just witnessed a multi-step, tool-using AI agent working entirely on your machine!
Next Steps: From Foundation to Powerhouse
Congratulations! You have a working, local-first AI agent. This is just the beginning. The OpenClaw ecosystem is designed for growth. Here’s where to go next:
- Explore More Skills: Browse the OpenClaw Skills & Plugins library. Add web search, calendar control, code execution, or email management.
- Customize the LLM: Experiment with different local models. Try a larger 70B model for complex reasoning or a tiny 1B model for lightning-fast responses on older hardware.
- Build a Custom Skill: The true power lies in creating skills tailored to your needs. Wrap a Python script for your specific data analysis or connect to a niche API.
- Implement Advanced Patterns: Look into multi-agent collaboration, where specialized agents (a researcher, a writer, a critic) work together under a supervisor agent to solve complex tasks.
- Add a Frontend: Replace the terminal loop with a web UI using frameworks like Gradio or Streamlit for a more polished experience.
Conclusion: Your AI, On Your Terms
Building your first agent with OpenClaw Core is more than a technical exercise; it’s a step toward reclaiming autonomy in the age of AI. You are no longer just a user of a black-box service. You are an architect, a trainer, and the sole beneficiary of a system that respects your privacy, adapts to your needs, and runs on your hardware. The local-first, agent-centric paradigm represents a fundamental shift—from consuming AI to cultivating it. You now have the foundation. Keep iterating, keep integrating, and build the intelligent assistant that truly works for you.
