The Nevo App is a self-improving AI agent system for macOS that coordinates specialized sub-agents to handle software engineering, operations, and system administration tasks autonomously -- and gets measurably better the longer it runs. It is available as a $100 software product from nevo.systems and runs natively on Apple Silicon.

Unlike cloud-based AI tools where your data leaves your machine with every prompt, Nevo runs locally. Your code, your files, your conversations stay on your hardware. The AI works for you, on your computer, under your control.

This guide covers everything from system requirements to running your first task. If you are new to AI agents, start with What Are AI Agents? for foundational context, then come back here for the hands-on setup.

What You Get with Nevo App

Nevo is not a chatbot with a download button. It is an orchestration system -- a coordinated team of 14 specialized AI agents that decompose tasks, execute them through an 8-stage quality pipeline, learn from errors, and write their own new capabilities over time.

Here is what ships in the box:

• OpenClaw daemon -- The always-on hub that connects Nevo to messaging platforms, manages sessions, and handles memory
• Claude Code engine -- The reasoning backbone with 36 skills, task management, hooks, and MCP integration
• QMD document retrieval -- Local search engine combining keyword and neural search, saving 92-96% of tokens versus brute-force context injection
• 14 specialized agents -- Purpose-built sub-agents for type checking, testing, linting, code review, research, incident analysis, security review, and more
• Error-to-rule pipeline -- Every unique mistake gets analyzed and converted into a permanent preventive rule
• Skill Forge -- Self-writing pipeline that creates new capabilities when Nevo identifies gaps in its own knowledge
• Memory system -- Brain-inspired three-stage pipeline that gives Nevo persistent memory across sessions
• Mission Control -- A gamified pixel-art dashboard where you can watch your agents work in real time

For a deeper understanding of how these systems work together, see Nevo: The Self-Improving AI Agent.

System Requirements

Nevo runs on macOS with Apple Silicon. Here is what you need.

Minimum Requirements

Software Prerequisites

You do not need to install most dependencies manually. The Nevo installer handles them. But you will need:

• An Anthropic API key -- Nevo uses Claude as its reasoning engine. You will need an active Anthropic account with API access
• A terminal -- You will use Terminal.app or any terminal emulator for the initial configuration
• Homebrew (optional) -- Nevo's installer can use Homebrew for dependency management, but it will install what it needs if Homebrew is not present

You do not need Python, Node.js, or any programming language installed. The installer bundles everything required.

Step 1: Download and Install

Download

Visit nevo.systems and download the Nevo App installer for macOS. The download is approximately 500 MB and includes all runtime dependencies.

Run the Installer

1. Open the downloaded .dmg file
2. Drag the Nevo icon to your Applications folder
3. Open Nevo from your Applications folder
4. macOS will ask you to confirm since Nevo is from an identified developer -- click Open

The first launch takes 60-90 seconds longer than usual. Nevo is unpacking its agent definitions, skill files, memory infrastructure, and the QMD search index. Subsequent launches are near-instant.

Grant Permissions

Nevo needs a few macOS permissions to operate effectively:

• Full Disk Access -- Go to System Settings > Privacy & Security > Full Disk Access and enable Nevo. Without this, Nevo cannot read or write files outside its sandbox
• Developer Tools (if prompted) -- Required for shell commands and scripts
• Network access -- Prompted automatically on first launch

Step 2: Configure Your API Key

Nevo uses Anthropic's Claude models as its reasoning engine. You need an API key from Anthropic to power Nevo's intelligence layer.

Get Your Anthropic API Key

1. Go to console.anthropic.com
2. Create an account or sign in
3. Navigate to API Keys in the left sidebar
4. Click Create Key and give it a descriptive name (e.g., "Nevo Agent")
5. Copy the key -- you will only see it once

Enter the Key in Nevo

On first launch, Nevo's setup wizard will prompt you for your API key. Paste it in and click Save.

If you need to update the key later, you can do so from the Nevo settings panel or by editing the credential file directly:

# API keys are stored securely at:
~/.nevo/credentials/anthropic.env

Understanding API Costs

Nevo uses three tiers of Claude models to keep costs efficient:

Typical daily API costs for moderate usage range from $2-10, depending on workload complexity and volume. Heavy development days with parallel agent execution can run higher.

Step 3: Set Up Memory

Memory is what separates Nevo from a stateless AI tool. Without memory, every session starts from zero. With it, Nevo accumulates knowledge about you, your projects, your preferences, and its own lessons learned.

How Nevo's Memory Works

Nevo's memory system is a three-stage pipeline inspired by how biological brains form memories:

1. Sensory buffer -- Raw session data is captured and held temporarily
2. Hippocampal encoding -- Important facts, preferences, and lessons are extracted and tagged
3. Neocortical consolidation -- Knowledge is organized into long-term storage, deduplicated, and made searchable

For a full technical deep dive, see How Nevo's Memory Architecture Works.

Initial Memory Configuration

During first-time setup, Nevo will ask you a few questions to seed its memory:

• Your name -- So Nevo knows who it is working for
• Your primary workspace -- The directory where your projects live
• Your communication preferences -- How verbose you want status updates to be
• Your technical background -- So Nevo calibrates its explanations appropriately

These are starting points. Nevo will learn far more about your preferences through normal use. Within a few sessions, it will know your coding style, your favorite frameworks, your naming conventions, and the standards you care about -- without you explicitly telling it.

Memory Health

You can check memory health at any time:

nevo health --memory

This reports the number of stored facts, session narratives, active rules, and the last consolidation timestamp. A healthy memory system should show regular consolidation activity and a growing fact count.

Step 4: Choose Your Workspace

A workspace is the directory Nevo treats as its project root. This is where it reads code, writes files, runs tests, and manages git operations.

Setting Your Default Workspace

The setup wizard will ask you to select a default workspace. You can point it at:

• An existing project directory (e.g., ~/Projects/my-app)
• A new empty directory that Nevo will populate
• Your home directory (if you want Nevo to have broad access)

Multiple Workspaces

Nevo supports working across multiple projects. You can switch workspaces at any time:

nevo workspace set ~/Projects/another-project

Each workspace maintains its own project-level rules, skills, and configuration. Rules you create for one project do not bleed into another unless you explicitly promote them to global scope.

Step 5: Verify Your Installation

Before you start using Nevo for real work, run through these verification steps to confirm everything is wired up correctly.

Run Your First Task

The simplest verification is to give Nevo something to do:

nevo "List the files in my current directory and tell me what this project does"

If Nevo responds with an accurate description of your project structure, the core pipeline is working: API connectivity, tool execution, and file system access are all functional.

Check the Agent Roster

Verify that all 14 specialized agents are loaded and available:

nevo agents --list

You should see the full roster: type-checker, test-runner, linter, code-critic, researcher, independent-reviewer, arbiter, incident-monitor, incident-analyst, token-optimizer, skill-writer, asset-creator, changelog-analyst, and security-reviewer. Each should show a status of "available."

Memory Health Check

Confirm the memory system is operational:

nevo health --memory

After your first interaction, you should see at least one session recorded, initial facts extracted, and the consolidation pipeline active.

Run the Full Health Check

For a comprehensive system verification:

nevo health --full

This checks API connectivity, agent availability, memory pipeline health, QMD search index integrity, skill inventory, rule count, and daemon status. Any issues will be flagged with specific remediation steps.

Step 6: Connect Your Communication Channels

Nevo communicates through 20+ messaging platforms via OpenClaw connectors. Telegram is the most popular -- it lets you message Nevo from your phone as if it were a team member.

1. Open the Nevo settings panel and navigate to Connectors > Telegram
2. Follow the guided setup to link your Telegram account
3. Send a test message to your Nevo bot

Once connected, you can send Nevo tasks from anywhere. Nevo receives the message, processes it on your Mac, and sends the response back. Discord, Slack, WhatsApp, and other connectors follow the same pattern.

Troubleshooting Common Issues

"API key invalid" Error

• Verify the key at console.anthropic.com -- it should start with sk-ant-
• Check that you copied the full key without trailing spaces
• Ensure your Anthropic account has API access enabled and sufficient credits
• Re-enter the key via: nevo config set anthropic_api_key YOUR_KEY

Nevo Is Slow to Respond

• Check your internet connection -- API calls require network access
• Verify you are not hitting Anthropic rate limits (check your usage dashboard)
• If running parallel agents, ensure you have sufficient RAM (32 GB recommended)
• Run nevo health to check if any subsystem is degraded

"Permission Denied" Errors

• Confirm Full Disk Access is enabled for Nevo in System Settings
• Check that your workspace directory has appropriate read/write permissions
• If using a project owned by another user, adjust permissions with chmod or chown

Agents Not Loading

• Run nevo agents --list to see which agents failed to load and why
• Most agent load failures are caused by missing skill files -- run nevo repair --skills to regenerate
• If a specific agent is consistently failing, check its definition file at .claude/agents/

Memory Not Persisting

• Run nevo health --memory to diagnose
• Check that the memory directory at ~/.nevo/memory/ exists and is writable
• Verify the consolidation pipeline is running: nevo health --memory --verbose
• If memory was corrupted, run nevo repair --memory to rebuild the index from raw session data

QMD Search Returns No Results

• The search index may need rebuilding: qmd update
• Verify the QMD collections exist: qmd list
• If collections are missing, re-run: nevo repair --qmd

What to Do First

You have Nevo installed, configured, and verified. Here are three things worth trying.

Analyze your codebase. Point Nevo at an existing project and ask for an architectural assessment. This exercises QMD search, file system access, and the reasoning pipeline.

Give it a coding task. Ask Nevo to add a feature, fix a bug, or write a test. Watch it decompose the task into stories, route them through the quality pipeline, and deliver reviewed code.

Make a deliberate mistake. Give Nevo an ambiguous instruction. Watch the incident monitor detect the error, the analyst diagnose the root cause, and a new preventive rule get generated. This is the engine behind Nevo's self-improvement.

Within a few days of regular use, you will notice Nevo getting noticeably better at the specific kinds of tasks you give it. That is the compound effect of rules, memory, and self-written skills working together.

Frequently Asked Questions

Does Nevo require an always-on internet connection?

Nevo requires internet access for API calls to Anthropic's Claude models, which power the reasoning engine. File operations, QMD search, memory, and local tool execution work without internet. If your connection drops mid-task, Nevo will pause and resume when connectivity returns -- it does not lose progress.

How much does the Anthropic API cost to run Nevo?

Costs depend on usage intensity. Nevo's model routing system automatically sends simple tasks to cheaper models (Haiku) and reserves expensive models (Opus) for complex reasoning. Typical daily costs for moderate development work are $2-10. You control your spending through Anthropic's usage limits and can set budget caps in Nevo's configuration.

Can I use Nevo with models other than Claude?

Nevo is built on Claude Code and optimized for Anthropic's Claude model family. The LiteLLM routing layer supports additional model providers, but the core agent orchestration, skill system, and quality pipeline are designed around Claude's capabilities. Using alternative models is possible for specific sub-tasks but not recommended as a full replacement.

Is my code sent to Anthropic when I use Nevo?

Yes -- your code is sent to Anthropic's API for processing when agents need to reason about it. Anthropic does not use API inputs for model training (per their API terms). If you need absolute data isolation, you can configure Nevo to use local models for certain tasks, though this reduces capability compared to Claude-powered reasoning.

Can I install Nevo on an Intel Mac?

No. Nevo requires Apple Silicon (M1 or later). The architecture depends on the Neural Engine and unified memory architecture that Apple Silicon provides. Intel Macs do not have equivalent hardware and cannot run Nevo's workloads efficiently. If you are on Intel hardware, consider the Nevo Pi as an alternative.

Next Steps

• What Are AI Agents? -- Foundational guide to understanding the AI agent landscape
• Nevo: The Self-Improving AI Agent -- Deep dive into Nevo's architecture and self-improvement systems
• How Nevo's Memory Architecture Works -- Technical exploration of the brain-inspired memory pipeline
• nevo.systems -- Download Nevo App and join the community