Quick Install — One Copy Gets It All

# Install Albert (brings the full agent engine with it)
cargo install albert-cli


# Launch
albert-cli

That's it. Albert spins up the REPL and the onboarding will start.

How it thinks

Albert operates in exactly three states:

This is enforced at the engine level. Albert will not hallucinate an answer, silently skip a step, or execute an ambiguous command.

Features

Sovereign Security

• Deny-first AST interception — every shell command is parsed by a native Rust pipeline before it reaches the OS. Command substitution, dangerous pipes (curl | bash), and unauthorized redirects are blocked at the source.
• Revoked flag access — the LLM cannot touch sandbox flags or security policies at runtime. Zero prompt-injection surface for privilege escalation.
• Zero-trust key storage — API keys live in ~/.config/albert/credentials.json, never in environment variables passed to subprocess.

LLM-Agnostic Core

Albert routes to any provider you configure. No vendor lock-in, no hardcoded defaults.

Slash Command Library

Memory & Context

• Session persistence — conversations survive restarts, stored in ~/.config/albert/sessions/
• Knowledge graph — entity/relation memory that tracks project-specific context across sessions
• RepoMap — automated structural navigation so Albert understands your codebase before it touches it
• MCP client — native Model Context Protocol support; plug in any third-party MCP server

RTK — Rust Token Killer

Integrated token-optimization proxy that intercepts outgoing context and applies structural filters. Typical savings: 60–90% on development operations like git status, cargo clippy, and file reads.

Cognitive Persistence & Identity

Albert builds a mental model of your project through two primary systems:

The Knowledge Graph (knowledge_graph.json)

This is Albert's Knowledge Base. When you say "lock this into memory," Albert uses a specialized tool to store structured facts, relationships, and observations.

• Persistence: Stored in ~/.ternlang/memory/knowledge_graph.json.
• Neurosymbolic Gap Recovery: If a tool enters an ambiguous state (State 0), Albert autonomously queries this graph. If he finds a matching entity or observation, he uses it to resolve the ambiguity and proceed to State +1 without bothering you.
• Content: Tracks project team members, architectural decisions, and hardware context.

Identity & Working Agreement (ALBERT.md)

This is Albert's Core Directive. It is the instruction set that defines his "brain" configuration for the current workspace.

• Customizable Behavior: By editing ALBERT.md in your project root, you can "re-program" Albert's personality, tone, and priorities.
• Directives: You can set specific rules like "always use async/await" or "respond with dry wit."
• Scope: Loaded dynamically on startup; changes take effect in the next session.

Reflection Log (memory.md)

A global, high-level summary of significant insights. Albert periodically runs a "reflection pass" (llm_reflect) to distill your conversations into single-line memories saved in ~/.ternlang/memory.md.

Installation

Prerequisites: Rust toolchain (cargo) — install here

# Install Albert (brings the full agent engine with it)
cargo install albert-cli

# Set your LLM key (pick any provider)
export GEMINI_API_KEY=AIza...          # Google Gemini — default, highest quota
export ANTHROPIC_API_KEY=sk-ant-...   # Anthropic Claude
export OPENAI_API_KEY=sk-...          # OpenAI / GPT-4o
# export XAI_API_KEY=xai-...          # xAI / Grok
# (Ollama: just run `ollama serve` — no key needed)

# Launch
albert-cli

Quickstart

# 1. Add your provider credentials
albert-cli /auth

# 2. Map the current repository
albert-cli /init

# 3. Start the REPL
albert-cli

On first launch Albert walks you through a setup sequence: cognitive style, provider routing, and model selection. After that, you drop straight into the REPL.

Repository layout

agent_albert_cli/
├── rust/
│   └── crates/
│       ├── api/              # Multi-provider LLM client (albert-api)
│       ├── runtime/          # Core loop, OAuth, MCP, session management (albert-runtime)
│       ├── commands/         # Slash command library (albert-commands)
│       ├── tools/            # Tool execution layer — bash, file ops, search (albert-tools)
│       ├── compat-harness/   # Manifest extraction and path resolution (albert-compat)
│       └── rusty-ternlang-cli/  # Main binary: albert (albert-cli)
├── src/                      # Python/legacy reference source
├── tests/                    # Validation surfaces
├── ALBERT.md                 # Agent working agreement for this repo
└── PARITY.md                 # Feature parity gap analysis vs. TypeScript origin

Ecosystem

Albert is one node in the Ternary Intelligence Stack — a full agentic platform built around ternary logic.

Development

cd rust

# Check everything compiles
cargo build --workspace

# Lint
cargo clippy --workspace --all-targets -- -D warnings

# Test
cargo test --workspace

The workspace uses resolver = "2" with unsafe_code = "forbid" and pedantic Clippy enforced across all crates.

A sovereign project of RFI-IRFOS — building the infrastructure for agentic intelligence.