A local AI agent can run right on a regular Windows computer without paying for every request to OpenAI, DeepSeek, or another external API. The model runs locally through Ollama, while DeepSeek Harness turns it from a regular chat into a working AI agent that can read and create files, work with projects, run commands, and complete multi-step tasks.
After the initial installation and model download, the main computations take place on your computer. There is no token-based billing, no need to rent a VPS, and no mandatory subscription to a cloud LLM. The more you use AI, the more noticeable the main advantage of this setup becomes: the model is already on your machine and can work for as long as your computer allows.
We tested this setup in practice on Windows with Ollama, DeepSeek Harness, and a local Qwen-family model. Below, we will look at what it offers, what tasks such an agent can handle, and how difficult it is to run.
What is a local AI agent
A local AI agent is a language model that runs on your computer and is given tools to perform real actions. It is not limited to answering in a chat window: the agent can examine a work folder, read several files, compare data, create new files, run a command, check the result, and continue working.
In simplified terms, the architecture looks like this:
You → DeepSeek Harness → local model via Ollama → files, commands, and tools → finished result
It is precisely the presence of a working environment that distinguishes an AI agent from a regular local chat. We covered the principle of such an environment in more detail in the article “Agent harness: how an AI agent runtime works”.
The key advantage: no need to pay for every request
When using most cloud AI services, computations take place on the provider's servers. The user either pays a subscription or pays for the API based on the number of input and output tokens.
The local setup works differently. The model is downloaded to the computer once and then uses your CPU, GPU, and RAM. A request to a local model does not generate a separate bill.
| Parameter | Cloud AI/API | Local AI |
|---|---|---|
| Payment for every API request | Usually yes | No |
| Mandatory LLM subscription | Depends on the service | Not required |
| Where the model runs | On the provider's servers | On your computer |
| Works without internet after downloading the model | Usually no | Yes, for local tasks |
| Number of local requests | Depends on the plan | Not billed by tokens |
| Model selection | From the service's models | Can be changed independently |
| Work data | Sent to an external service | Can remain on the computer |
This is especially interesting not for a few questions per month, but for ongoing work: programming, document processing, file analysis, experiments with agents, and internal AI tools.
This is no longer just a local ChatGPT
The language model itself can be run through Ollama and used in the terminal, or connected to your own application. We covered this layer in detail separately in the article “Ollama: what it is, how it differs from ChatGPT, and how to use local models”.
But it is much more interesting to give the model a working environment. In our setup, this role is played by DeepSeek Harness.
A regular model receives a question and generates an answer. An AI agent receives a task and can perform a sequence of actions:
- understand the goal;
- examine the files and project structure;
- choose the right tool;
- perform an action;
- read the result;
- perform the next step if necessary;
- deliver the final result.
As a result, a request may look not like “tell me how to fix this program,” but like “examine the project, find the cause of the error, fix it, check the result, and prepare a brief report.”
What a local AI agent can do in practice
The capabilities depend on the selected model and connected tools, but even a relatively compact local model is already suitable for a wide range of practical tasks.
Work with files
The agent can read documents and source files from the working directory, compare them with each other, create new materials, and modify existing ones.
For example, you can give it a folder with Markdown, JSON, CSV, or source code and ask it to understand all of its contents, rather than uploading each file to a separate chat.
Work with code
A local AI agent is especially useful as a developer assistant. It can examine a project’s structure, find the necessary files, write and modify code, run available commands, read execution results, and continue working.
This is already noticeably closer to the “give it a task” format than to the classic copying of code fragments between an IDE and a chatbot.
Process documents and data
You can provide the agent with a set of local documents and give it a task: find the necessary information, bring the data into a consistent format, create a table, JSON, Markdown document, or final report.
This approach is suitable for catalogs, technical documentation, logs, exports, text archives, and other recurring materials.
Perform multi-step tasks
The strength of an agent harness is that the model sees not only the original request but also the results of its own actions. This allows it to structure its work as a chain:
receive a task → examine the materials → perform an action → check the result → continue → produce the final result.
This way of working underpins more autonomous systems. A separate example of this approach can be found in the article on using Hermes Agent for business automation.
Example: from one command to a finished result
Imagine that there is a small software project in the working folder. Instead of a sequence of dozens of questions, you can give the agent one overall task:
Examine the project. Find the reason why CSV import is not working correctly. Fix the code, run the available tests, and prepare a brief description of the changes made.
The AI agent first examines the project structure, then finds the files related to import, reads the code, makes changes, runs the checks, and analyzes their results.
A person formulates the end goal. Harness and the model break it down into actionable steps.
The same approach can be applied beyond programming. Instead of a project, it can be a folder of documents, a product catalog, a set of reports, or work materials.
What a local system consists of
| Component | What it does |
|---|---|
| Ollama | Downloads and runs an AI model on the computer and provides a local API |
| Local model | Analyzes the task, generates responses, and chooses actions with tool calling support |
| DeepSeek Harness | Creates the agent environment, Web UI, sessions, Workspace, and connects tools |
| Workspace | Working folder with a project, documents, or other materials |
| PowerShell / Node.js | Provide the system environment for Harness to run on Windows |
In other words, Ollama and DeepSeek Harness do not compete with each other. They perform different tasks and complement each other well.
Ollama runs the model. DeepSeek Harness turns that model into an agent.
What Ollama provides
Ollama lets you download a compatible model and run it directly on Windows, macOS, or Linux. Once launched, other programs can access the model through a local API.
This means the same local AI can later be used not only with Harness. It can be connected to Python applications, custom interfaces, automations, and other agent environments.
The model is also easy to replace: you can start with a relatively compact model today and switch to a more powerful one after upgrading your computer, without rebuilding the entire architecture.
What DeepSeek Harness adds
DeepSeek Harness is an open-source agent harness from DeepSeek AI. It has a browser-based Web UI, workspaces, sessions, and a tool system. The agent can read and modify Workspace files, execute commands, and use the results of these actions in the next steps of a task.
A separate overview of the interface and basic setup is available in the article “DeepSeek Harness: what it is and how to install an AI agent”.
For a local setup, it is especially convenient that Ollama already has official integration with DeepSeek Harness. So there is no need to connect the components manually through your own intermediary server.
Which local model to use
It is better to start not with the largest model, but with one that runs reliably on your computer and supports the tools the agent needs.
| Level | Example | Suitable for |
|---|---|---|
| Compact | A model around 4B | First look, simple texts, and basic tasks |
| Practical starting point | An 8B-class Qwen | Documents, code, files, and experiments with an AI agent |
| Advanced | A model around 14B | More complex requests with additional memory available |
| Powerful workstation | Large coder models | Large projects and complex programming tasks |
For the first practical run, we used qwen3:8b. This model is compact enough to test the entire Ollama + Harness setup on a regular computer, while still supporting tool use.
Do you need an expensive computer
You do not need to buy a dedicated server or a professional GPU workstation for your first local AI agent. You can start with an existing Windows PC by choosing a model size that fits its capabilities.
The configuration we tested ran on a system with roughly 16 GB of RAM and an NVIDIA RTX 3050 with 6 GB of VRAM. The model used both the GPU and regular system memory.
If there is no graphics card, Ollama can run computations on the CPU. If the computer is more powerful, you can move to larger models and get higher speed.
The main idea is simple: a local AI system can scale along with your computer. You do not need to buy expensive hardware right away to get started.
Can you create your own personal AI assistant
Yes. Ollama lets you create custom model configurations through a Modelfile.
You can set:
- a system prompt;
- communication style;
- work terminology;
- context size;
- generation parameters;
- examples of desired responses.
For example, the same base model can be turned into a technical helper, a document assistant, or a local assistant for a specific project.
There is no need to store another full copy of the model weights: the configuration is created on top of the existing base model.
Why local AI is especially convenient for ongoing work
Running locally changes the economics of using AI itself. When the cost is not tied to every input and output token, the model can be used more actively for intermediate operations.
For example, an agent can reread files repeatedly, classify local data, redo results, run checks, and experiment with different options without thinking about the cost of every additional model call.
This is convenient for development, testing AI agents, internal tools, and processes with many repetitive requests.
Data can stay on your computer
A local model has another practical advantage: prompts and working files do not need to be sent to an external LLM provider.
Ollama runs the model locally, and DeepSeek Harness can work with a local Workspace. As a result, documents, code, and processing results can stay on your computer.
For internal documentation, source code, work archives, and corporate materials, this can be no less important an advantage than the absence of API billing.
How to deploy a local AI agent on Windows
The complete setup consists of several stages, but the architecture itself is quite simple.
- Check your computer. Check the amount of RAM, the graphics card, and free disk space.
- Install system components. Our setup uses Node.js, PowerShell 7, and Ollama.
- Download a local model. For the first run, you can use a Qwen 8B-class model.
- Test the model separately. Make sure Ollama runs it locally.
- Install DeepSeek Harness. It creates a working agent environment.
- Create a Workspace. This is the folder the agent will work with.
- Launch the integration. Ollama connects the selected model to Harness.
- Give it a test task. For example, ask the agent to read several files and create a new document.
In the current integration, the launch looks very brief:
ollama launch dsh --model qwen3:8b
After launch, DeepSeek Harness opens the Web UI in the browser, while the model continues to run through local Ollama.
What can be built on top of this setup
After the basic setup, the local model stops being just an experiment. It becomes one of the components of your own AI infrastructure.
Based on it, you can gradually build:
- a local programming assistant;
- an assistant for internal documents;
- a tool for analyzing files and spreadsheets;
- a generator and editor for work materials;
- an AI assistant for a specific project;
- a local foundation for your own Python and JavaScript applications;
- an AI agent with a set of specialized tools;
- a prototype of the company's internal AI system.
If needed, a local model can be combined with other systems. For example, perform simple high-volume operations locally, while sending particularly complex tasks to a more powerful model.
Who benefits most from a local AI agent
A local setup is especially appealing to those who use AI regularly rather than occasionally.
| Who | What they get |
|---|---|
| Developer | An AI agent for working with code and projects |
| Freelancer | A tool without ongoing API costs |
| Small business | A foundation for its own internal AI tools |
| Analyst | Local processing of files, spreadsheets, and data |
| Content creator | An assistant for working with large local archives of materials |
| AI developer | An environment for experimenting with models, tools, and agents |
How much does working with local AI cost
A local setup has no token meter that increases the cost with every request. Once the computer, Ollama, Harness, and the model are ready, you can use the local LLM repeatedly without paying separately for each request.
That is why the local approach works especially well where AI is used heavily: in development, processing large sets of files, continuous testing, and agent workflows.
Instead of buying each additional million tokens, you use the computing resources already sitting on your desk.
Complete step-by-step setup of Ollama + DeepSeek Harness on Windows
In this article, we deliberately did not turn the story of local AI into several screens of PowerShell commands. To understand the technology, it is enough to know the architecture and the main stages.
For those who want to immediately replicate a proven setup, we have prepared a complete step-by-step guide. It covers the entire process from checking your computer to a ready local AI agent.
The full version includes specific commands and settings for:
- checking Windows, RAM, GPU, and drives;
- installing Node.js, PowerShell, and Ollama;
- placing models on the required drive;
- downloading and checking a local model;
- installing and launching DeepSeek Harness;
- setting up the Workspace;
- connecting Ollama to Harness;
- checking CPU/GPU;
- configuring the model context;
- creating your own model through Modelfile;
- configuring your own custom preset;
- creating a convenient launch script;
- troubleshooting common issues;
- updates and configuration backups.
That is, not a set of scattered tips, but a ready-made sequence of actions, actually tested on Windows.
Get the complete step-by-step guide to installing a local AI agent →
Frequently asked questions
Do I need to pay for requests to a local model?
No. If the model runs locally through Ollama, requests to it are not billed by token count like requests to an external API.
Do I need an OpenAI or DeepSeek API key?
No, not for the described setup with a local model. Ollama runs the model directly on the computer, and DeepSeek Harness connects to it locally.
Do I need a powerful graphics card?
Not necessarily. Ollama can also work via CPU. A compatible GPU speeds up generation and makes larger models more comfortable to use.
Can AI be used without the internet?
Yes. The internet is needed for the initial download of the software and model. After that, the local model can work offline as long as the task does not require access to an external website or online service.
Is it necessary to use qwen3:8b?
No. It is a convenient starter model for a tested configuration. Ollama allows you to install other compatible models and switch between them.
Can I change the model later?
Yes. This is one of the advantages of this architecture: Ollama, Harness, and Workspace remain, while the model can be replaced with a more compact, newer, or more powerful one.
Can I customize the personality and specialization of the local assistant?
Yes. Through the Ollama Modelfile and agent environment settings, you can define a custom system prompt, style, model parameters, and behavior examples.
How does DeepSeek Harness differ from Ollama?
Ollama runs the AI model itself and provides a local API. DeepSeek Harness provides the model with an agent environment: Workspace, tools, work with files, commands, and multi-step tasks.
