Navree for AI

AI-native, from your editor to your product.

Your coding agent builds with skills for every common task, Navigator to see the running app and docs written for models. Your product gets a typed AI SDK, agents that act as the user, answers from your own data and MCP servers. Both are in the box, open source and self-hosted.

Set up your agent Read the AI docs

agent · ~/code/crm

navree mcp

The deals page is empty since I pulled main, and the API returns 500. Fix it.

navree · last_error()

500 GET /api/v1/deals request_id=0199c4b1

error: no such column: deals.expected_close_date

navree · describe_schema(table: "deals")

deals: id, title, amount_cents, currency, stage, position, …

pending migration: m20261026_000004_add_expected_close_date

Run(navree migrate)

Applied m20261026_000004_add_expected_close_date

The code you pulled reads deals.expected_close_date, but the migration that adds it hadn’t run on your database. I ran navree migrate; GET /api/v1/deals answers 200 again.

12 tools · read-only · stdio

01 Build with agents

Your coding agent, fully briefed.

An agent does its best work in code that is predictable, explicit and checked, and every Navree app is all three. Navree adds what an agent can’t read from the code: the steps for each task, a view of the running app, and docs in the form it reads best.

skills/

A skill for every common task

A skill is a folder with a SKILL.md: when to use it, then the steps, the commands, a template that compiles, the checks to run and the mistakes to avoid. Agents read every description up front and load a skill only when the task matches, so a project carries all of them for a few lines each.

skills, one per task: 64
files, checked against the code: 75

navree skills:install

Or npx skills add NavreeHQ/navree, or copy the folders by hand.

Agent skills skills/index.json

navree.com/skills/64 folders

navree mcp

Navigator shows your agent the running app

A coding agent that reads your files still guesses at the running app. Navigator, the MCP server built into the CLI, answers from the app itself: the routes once every module is wired, the schema as it really is, and what failed in the last request.

Read-only: no tool writes anything
Runs on your machine over stdio, for one project
Never part of your production binary
Docs matched to the Navree version in your lockfile

claude mcp add navree -- navree mcp

Any MCP client that starts stdio servers runs the same command.

Navigator

navree mcp · tools12 tools

Navigator’s tools and what each one answers
The app
app_info	Versions, features, modules, database driver
list_routes	Method, path, access rule, handler, module
module_graph	Imports, exports and providers per module
list_providers	Scope, owner, visibility, dependencies
list_commands	Every command, as navree list shows it
The data
describe_schema	Tables, columns, indexes, pending migrations
query_database	One read-only query, at most 100 rows
What happened
read_logs	Recent lines by level, target or request
last_error	The last error, its request and its logs
Settings and docs
read_config	The merged configuration, secrets redacted
search_docs	These docs, for your Navree version
read_doc	One docs page as Markdown

llms.txt

Docs written for models

All 156 docs pages are also plain Markdown at a predictable URL, indexed in llms.txt and bundled in llms-full.txt. Every page has Copy page, and Open in Claude or ChatGPT.

navree.com/llms.txt

# Navree > The complete backend framework for Rust. Modular, API-first and AI-native. Everything your backend needs, checked by the compiler. Navree is a batteries-included Rust framework for building secure, scalable server-side applications. Modules and dependency injection give every app the same clear structure, and auth, workspaces, an ORM, queues, search, real time, monitoring, deployment and AI come in the box. Every link below is a docs page as Markdown. All of them in one file: https://navree.com/llms-full.txt. Any page of https://navree.com/docs/ is also available as Markdown: replace the trailing slash of its URL with `.md`. ## Prologue - [Introduction](https://navree.com/docs/prologue/introduction.md): What Navree is, the ideas it is built on, what comes in the box, who it's for and how to read these docs.- [Release notes](https://navree.com/docs/prologue/release-notes.md): Navree 0.1.0, the first release: the framework's modules, workspaces, the tools and packages of the first-party ecosystem, AI-native tooling, the CLI and the reference CRM.- [Roadmap](https://navree.com/docs/prologue/roadmap.md): Where Navree goes after 0.1: the 1.0 API freeze, long-term support, more drivers and starter kits, Windows services and ongoing performance work.- [Contributing](https://navree.com/docs/prologue/contributing.md): How the Navree repository is laid out, the crate-layer rule and the test that enforces it, running the tests, code style, and contributing to these docs. ## Getting started - [Installation](https://navree.com/docs/getting-started/installation.md): Install Rust and the `navree` CLI, create an app with `navree new`, and run it with `navree dev`.- [Your first app](https://navree.com/docs/getting-started/your-first-app.md): Build a small task-list API with an entity, a migration, validation, JWT authentication, access rules and feature tests, from `navree new` to green tests.- [Configuration](https://navree.com/docs/getting-started/configuration.md): Typed configuration from `.env`, `config/app.toml` and `APP_*` environment variables: precedence, nesting, the application key and your own sections.- [Directory structure](https://navree.com/docs/getting-started/directory-structure.md): What every file of a new Navree app is for, where generated code goes, and how the framework's own repository is laid out.- [Starter kits](https://navree.com/docs/getting-started/starter-kits.md): Production-ready apps from one command: a SaaS kit with a Next.js and shadcn/ui front end, an API kit and a microservice kit.- [Deployment](https://navree.com/docs/getting-started/deployment.md): Build a release binary, configure it through the environment, run the server, queue workers and the scheduler under a process manager, and put it behind a reverse proxy. ## Architecture concepts

AGENTS.md

House rules in every new app

navree new writes an AGENTS.md with the app’s layout, commands, generators and conventions, and a CLAUDE.md that imports it. Your agent knows how the app is built before its first change, and your team adds its own rules in one place.

Layout
Commands
Generators
Conventions
Before you finish

crm/AGENTS.mdnavree new crm

# AGENTS.md Instructions for coding agents working on crm, a Navree app: a Rustbackend built from modules wired by dependency injection. Read this filebefore changing code. ## Layout ```textconfig/app.toml        settings shared by every environment (committed).env                   this machine's secrets, such as APP_KEY (never committed)src/main.rs            runs the app: `serve` by default, or any other commandsrc/app.rs             the root module: every module, configured oncesrc/abilities.rs       who may do what: permissions and ability rulessrc/modules/<name>/    feature modules: mod.rs, controller.rs, service.rs,                       entity.rs, dto.rs, migrations/, tests/tests/                 tests that boot the whole app``` ## Commands ```shnavree dev                                  # serve on http://127.0.0.1:8080, rebuild on savecargo test                                  # every test; each gets its own SQLite databasecargo clippy --all-targets -- -D warnings   # must passcargo fmt                                   # must leave nothing to changenavree check                                # validate the module graph without bootingnavree routes                               # every route with its access rulenavree migrate                              # run pending migrationsnavree list                                 # every command of the app``` `navree <command>` runs `cargo run --quiet -- <command>` here. The APIreference is served at http://127.0.0.1:8080/api/docs while `navree dev`

Set up your agent in four steps

The full setup

01Create an appWrites AGENTS.md and CLAUDE.md with the app's conventions.
navree new crm
02Install the skillsCopies every skill into .claude/skills and .agents/skills.
navree skills:install
03Connect NavigatorCursor, Codex and VS Code take the same command.
claude mcp add navree -- navree mcp
04Point it at the docsOr any page's Markdown, such as /docs/basics/validation.md.
https://navree.com/llms.txt

02 Build AI into your product

Models are a service like any other.

AiModule puts every major model provider behind one typed service: named in configuration, injected where you need it, faked in tests. Agents act through your services as the signed-in user, retrieval answers from your own data, and MCP servers put your app in any AI client.

One service for

Anthropic
OpenAI
Google Gemini
Mistral
Ollama
AWS Bedrock

Text from any model, behind one service

Inject Arc<Ai> and ask. The provider's API, keys, retries, failover and usage metrics are the SDK's job, so your code never imports a vendor client.

Anthropic, OpenAI, Google Gemini, Mistral, Ollama and AWS Bedrock
Models named by their job, such as fast, in config/app.toml
Failover to the next model when a provider is down

Generating text

crates/crm-deals/src/controller.rs

/// Two sentences on where the deal stands.
#[get("/{id}/summary")]
#[can(Read, Deal, from = "id")]
async fn summary(
    &self,
    uow: Uow,
    CurrentAccess(access): CurrentAccess,
    deal: Authorized<Deal, Read>,
) -> Result<Json<serde_json::Value>> {
    let deal = self.deals.show(&uow, deal.into_inner()).await?;
    let timeline = self.insights.timeline(&uow, &access, deal.id).await?;
    let summary = self
        .ai
        .text(format!("Deal \"{}\". Activity:\n{timeline}", deal.title))
        .system("You summarize CRM deals for sales managers in two sentences.")
        .model("fast")
        .await?;
    Ok(Json(json!({ "summary": summary.text })))
}

config/app.toml

[ai.models.fast]
provider = "anthropic"
model = "claude-sonnet-5-5"
fallbacks = ["backup"]

[ai.models.backup]
provider = "openai"
model = "gpt-5"

01
Models act as users
Agent and MCP tools run with the permissions of the user they act for, and every write goes through your services, your access rules and your audit log.
02
Providers are configuration
Code names a model by its job, such as fast or embed, and config/app.toml maps it to a provider. Moving vendors, or to Ollama on your own hardware, changes no code.
03
Your data stays yours
Nothing goes to a provider unless you configure one. Prompts and outputs aren't logged unless you turn it on, and secrets are redacted wherever Navree prints configuration.
04
Tested like everything else
AiFake answers in tests without a network or a key, records every request for assertions, and lets your tools run for real against the test database.

The AI docs

Start with your agent.

Four commands set up skills, Navigator and the docs. The AI SDK is one feature flag away.

Set up your agent