# AgenticSeek setup: how to run it locally, and when a team needs an open-source system

> Running AgenticSeek locally means Docker and a local model, and its repository walks through both. When a team needs shared memory, roles and review instead of one machine, the open-source AI Operating System Kortix is where that work moves.

URL: https://agenticseekalternative.com/agenticseek-setup-guide

_Commands_

## Ship it in three commands, or self-host it

The same loop runs on Kortix Cloud and on a server your team controls.

### Install and ship

`terminal`

```sh
curl -fsSL https://kortix.com/install | bash
kortix init
kortix ship
```

Source: README.md in https://github.com/kortix-ai/suna

### Self-host

`terminal`

```sh
curl -fsSL https://kortix.com/install | bash
kortix self-host init --domain kortix.example.com --admin-email you@example.com
kortix self-host start
```

Source: kortix.com/docs/host

## What running AgenticSeek locally takes

AgenticSeek is a local AI agent that runs on your own hardware, and its repository describes it as a fully local alternative to Manus AI. Setup starts with three pieces of software: Git, Python 3.10.x, and Docker Engine with Docker Compose. You clone the [AgenticSeek repository](https://github.com/Fosowl/agenticSeek), copy `.env.example` to `.env`, and set `WORK_DIR` to the folder the agent may read and write, along with the ports its services use.

A local model does the reasoning. The repository lists Ollama and LM-Studio as the local providers, and `config.ini` names the provider and the model, with `deepseek-r1:14b` as its worked example. SearxNG and Redis run in Docker beside the model for web search, and `./start_services.sh full` opens the web interface on `localhost:3000`. Every part of the stack runs on the machine.

## Where one machine stops and a team starts

AgenticSeek is built for one operator on one machine. Its configuration is a single `config.ini` on that machine, and both its sessions and its working directory stay on the local disk. There is no shared memory between people, no roles or permissions, and no review step before the agent changes something, so you watch it work and take the result. That fits a developer exploring a local agent, and it stops fitting as soon as a second person needs the same context, or someone else must approve what the agent changes.

## Moving the team to Kortix, the open-source AI Operating System

Kortix is the open-source AI Operating System: your agents, their skills, your company memory, and every connector in one git repo you own, with the agents working on real cloud computers. Where AgenticSeek keeps its state in one `config.ini` on one disk, Kortix keeps the whole system in files a team can clone, review and own.

One isolated sandbox per session. Each session has its own isolated machine and branch, so several run at once without touching each other. Session work reaches `main` through a change request. Merge is default-deny for agents, so a person reviews the change before it lands. Models and hosting stay with your team. Any model provider with your own keys. Or the ChatGPT plan you already pay for. Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free. The full setup guide is in the [Kortix docs](https://kortix.com/docs), and the comparison table on this page sets the two systems side by side.

## What changes for a team

- Work no longer waits on one machine: sessions run in parallel, each on its own branch.
- Setup becomes reviewable: the agents, skills and memory live in a repo with history.
- A change waits for a person: nothing reaches `main` until someone approves it.
- Access is per-person and per-agent: roles, groups, and an audit trail scope who can do what.
- Models and hosting are the team's call: bring your own keys, and run it where you need it.

_Compare_

## The setup, side by side

The Kortix column quotes Kortix; the AgenticSeek column comes from its own repository.

| | Kortix (recommended) | AgenticSeek |
| --- | --- | --- |
| Open source | Yes | Yes |
| Setup lives in | One git repo you own | A config.ini on one machine |
| Models | Any provider with your own keys | A local model through Ollama or LM-Studio |
| Where it runs | Kortix Cloud, your VPC, or on-prem | Your own machine |
| Isolation | One sandbox and branch per session | Tasks share one machine |
| Review | A person approves the change request | No review step |
| Shared context | Company memory as files in the repo | Sessions saved on the local disk |

_FAQ_

## AgenticSeek setup questions

### What hardware does AgenticSeek need?

For a local model, the repository asks for a GPU that can run a 14B model at minimum, and it recommends a reasoning model such as Magistral or Deepseek. Its FAQ maps the sizes: 14B on 12GB of VRAM (an RTX 3060) covers simple tasks, 32B on 24GB or more (an RTX 4090) gets through most work, and 70B and up on 48GB is what it suggests for advanced use. A 7B model on 8GB is under what it recommends.

### Do I need an API key to run AgenticSeek locally?

No. The repository says API keys are optional for anyone running a local model, which it calls the primary purpose of the project, so an empty key field is expected when the hardware is enough. Ollama and LM-Studio both serve local models without a key. A cloud API key is only the fallback for a machine that cannot run a local model at those sizes.

### Can I run AgenticSeek on a separate server?

Yes. The repository documents running the model on a dedicated machine and pointing `config.ini` at it over the network with Ollama or any OpenAI-compatible server such as llama.cpp. No AgenticSeek code runs on that server; you set `provider_server_address` to its address and keep `is_local = False`.

### Can I run AgenticSeek for a team?

AgenticSeek runs for one operator on one machine, with a single `config.ini`, local sessions, and no shared memory, roles or review. A team that needs several agents working at once, one memory it shares, and a person approving each change moves to Kortix, the open-source AI Operating System.

## Run the work on a system the team owns.

Start with one job, then grow from there.

[Try Kortix](https://kortix.com) · [Read the docs](https://kortix.com/docs)

Open source · Any model, your keys · Self-host, VPC, or on-prem