{{agentName}} Docs

Overview

{{agentName}} is a microkernel AI agent. It routes every turn, runs tools safely behind approval layers, and remembers what matters across sessions. One runtime powers three surfaces (CLI, Web UI, and chat), all sharing the same gateway, memory, tools, and usage accounting.

The core idea is simple. Before a turn executes, a local signal pass and a small judge model pick the lowest tier that can complete the work reliably, so you stop overpaying for trivial turns while keeping the strong models for the hard ones.

{{agentName}} runs on the Robinhood Chain and is paired with the ${{ticker}} community token. See the ${{ticker}} token section for the contract address and how to buy.

Quickstart

Windows, macOS, and Linux use the same setup path. Five commands and you are live.

# 1. install uv (manages its own Python)
curl -LsSf https://astral.sh/uv/install.sh | sh
# 2. install {{agentName}}
uv tool install --python 3.12 "{{pkg}}[recommended]"
# 3. connect a provider
{{cli}} onboard
# 4. start the gateway
{{cli}} gateway run
# 5. run your first turn
{{cli}} chat

Installation

1. Install uv

{{agentName}} installs into an isolated tool environment and manages its own Python, so you do not need Python first.

curl -LsSf https://astral.sh/uv/install.sh | sh
. "$HOME/.local/bin/env"

2. Install {{agentName}}

Pull the recommended profile, router plus the on device memory stack, from the latest release wheel.

uv tool install --python 3.12 "{{pkg}}[recommended]"

3. Connect a provider

Run the onboarding wizard to pick a backend and set your key, or point it straight at one with no prompts.

{{cli}} onboard
# no prompts:
{{cli}} onboard --provider openrouter \
  --api-key-env OPENROUTER_API_KEY

Configuration

Configuration lives in ~/.{{cli}}/config.toml and can be overridden per project with a local {{cli}}.toml. Secrets are read from environment variables, never written to disk.

# ~/.{{cli}}/config.toml
[router]
mode = "recommended"   # recommended | cheapest | strict
on_device = true

[memory]
embeddings = "onnx-local"

[providers.openrouter]
api_key_env = "OPENROUTER_API_KEY"

Key	Default	What it does
`router.mode`	`recommended`	How aggressively to downshift tiers
`router.on_device`	`true`	Keep the signal pass and judge local
`memory.embeddings`	`onnx-local`	Embedding backend for semantic recall
`gateway.port`	`18791`	Local gateway bind port

Routing

Every turn earns the right model. A local signal pass and a small judge model choose the cheapest capable tier before execution starts.

Read the message. The full turn is classified by difficulty, risk, context, and intent.
Extract signals. Local rules identify debug work, strict formats, long context, and agentic tasks.
Judge the tier. A small model selects the lowest tier that can complete the work reliably.
Run the model. The chosen tier maps to a concrete provider profile for that turn.

Tiers

Turns land in one of four tiers. The router always tries the lowest tier that can still do the job.

Tier	Name	Typical work
`R0`	Trivial	Greetings and one liners
`R1`	Simple	Routine edits and focused tasks
`R2`	Hard	Refactors and nontrivial debugging
`R3`	Critical	Production and cross service work

Guardrails

Guardrails keep routing stable so the cheapest tier bias never costs you quality.

No downgrade. Recent higher tier turns stay warm, protecting continuity and model cache reuse.
Sticky tier. Short follow ups inherit the active workstream instead of dropping context.
Complaint up. A failed answer raises the next turn instead of repeating the same attempt.

Surfaces

One runtime, three ways in. CLI, Web UI, and chat share the same gateway, memory, tools, approvals, and usage accounting.

CLI. Configure a provider, start the gateway, and run full agent turns from the shell.
Web UI. Run sessions, review approvals, publish artifacts, and inspect replay data at http://127.0.0.1:18791/control/.
Chat channels. Bring the same runtime into the messaging tools your team already uses.

CLI reference

Command	What it does
`{{cli}} onboard`	Pick a backend and set your key
`{{cli}} gateway run`	Start the shared local runtime
`{{cli}} chat`	Interactive chat session
`{{cli}} agent -m "..."`	Fire a single one shot turn
`{{cli}} memory search "..."`	Query personal memory
`{{cli}} usage`	Show cost and tier accounting

Providers

One schema, every provider. Point {{agentName}} at the backend that fits the work. Switching never requires application code changes.

OpenCAPOpenRouterOpenAIAnthropicGeminiDeepSeekDashScopeOllamaQwenMiniMax

${{ticker}} token

{{agentName}} is paired with ${{ticker}}, a community token on the Robinhood Chain. It is a community token with no promise of return.

Field	Value
Chain	Robinhood Chain
Ticker	`${{ticker}}`
Contract	`{{contractAddress}}`
Trade on	{{buyLabel}}

{{contractAddress}}

Buy ${{ticker}} on {{buyLabel}} →

FAQ

Do I need Python installed first?

No. {{agentName}} installs through uv into an isolated tool environment and manages its own Python.

Does my memory leave the machine?

No. Routing and embeddings stay local. On device ONNX embeddings power semantic recall without sending memory to a remote model.

Can I force a specific tier?

Yes. Set router.mode = "strict" to pin higher tiers, or "cheapest" to push downshifts harder.

Is ${{ticker}} required to use {{agentName}}?

No. The runtime is fully usable on its own. ${{ticker}} is a community token on the Robinhood Chain.