temm1e-labs/temm1e

Built with Production-Grade Plugin for Claude Code

Autonomous AI agent literally a SENTIENT and IMMORTAL being runtime in Rust.Deploy once. Stays up forever. Now grows itself.

167K lines · 2,954 tests · 0 warnings · 0 panic paths · 25 crates · Windows · macOS · Linux · full computer use · 13 free web search backends · JIT swarm · prompt caching · witness verification (default-on)

14 Layers of Self-Learning

Lambda Memory — episodic facts that fade, not disappear Engram Memory — permanent facts the agent curates itself, always-on yet never overflowing the window Cross-Task Learnings — strategic lessons that persist across tasks Blueprints — proven multi-step procedures with fitness scores Tem Anima — user personality and communication style profiling Recall Reinforcement — memories used more often become harder to forget Memory Dedup — near-duplicate memories merge automatically Core Stats — sub-agent reliability tracked per specialist core Tool Reliability — tool success rates by task type over 30-day windows Classification Feedback — empirical cost and round priors per category Skill Tracking — which skills are actually used vs sitting idle Prompt Tier Tracking — cost-effectiveness per prompt complexity tier Consciousness Efficacy — continuous A/B test of the consciousness observer Eigen-Tune Collection — training pairs captured from every LLM call

All 13 loops scored by V(a,t) = Q × R × U — the unified artifact value function

1 Self-Distillation & Self-Finetune Layer

Eigen-Tune — trains a local model from conversations, graduates through statistical gates (Wilson 99% CI + SPRT + CUSUM), serves locally — zero added LLM cost

Design · Setup · Safety Chain

Collect → Score → Curate → Train → Evaluate → Shadow → Monitor. Double opt-in: [eigentune] enabled = true + enable_local_routing = true

1 Self-Growing Mechanism

Tem Cambium — Tem writes its own Rust code that compiles, lints clean, and passes tests

Research Paper · Theory

Heartwood (immutable kernel) · Cambium (growth layer) · Bark (runtime surface) · Rings (history). Toggle with /cambium on · /cambium off

1 Verification Layer (NEW in v5.3)

Witness — the agent pre-commits a machine-checkable contract (Oath), an independent Witness verifies the work against the contract, and a tamper-evident hash-chained Ledger records every claim and verdict. The agent cannot self-mark anything as "done".

Research Paper · Implementation · Experiment Report

27 deterministic Tier 0 predicates · Tier 1 & 2 LLM verifiers (single-model policy) · tamper-evident SQLite Ledger anchored in temm1e-watchdog · 5 invariants (Pre-Commitment, Independent Verdict, Immutable History, Loud Failure, Narrative-Only FAIL) · 1,800 simulated trajectories at 88.9% lying detection, real-LLM PASS + FAIL verdicts captured on Hive-worker swarm in v5.5.0. ON by default since v5.5.0 (Warn strictness; complexity-gated to code-shaped turns; Hive workers covered with parent workspace propagation). Toggle off via [witness] enabled = false

---

Install in 30 seconds

Two commands. No Rust toolchain, no build step, no config files.

curl -sSfL https://raw.githubusercontent.com/temm1e-labs/temm1e/main/install.sh | sh
temm1e tui

The installer pulls the latest pre-built binary from GitHub Releases for your OS+arch (macOS Intel/Apple Silicon, Linux x86_64/ARM64 musl+gnu), verifies the SHA-256 checksum, and drops it in ~/.local/bin (or ~/bin if that’s already on your PATH). The second command launches the interactive TUI — a first-run wizard walks you through provider + API key setup with arrow keys. After that, you’re chatting with Tem.

Prefer a global install? Pipe --global and it’ll go to /usr/local/bin instead:

curl -sSfL https://raw.githubusercontent.com/temm1e-labs/temm1e/main/install.sh | sh -s -- --global

Windows users: as of v5.4.5, Windows is a first-class supported platform — the shell tool routes through powershell.exe (5.1 ships with every Windows 10/11), browser automation survives stale Chrome singleton locks (GH-50), config reads from %PROGRAMDATA%\temm1e\ and %USERPROFILE%.temm1e, and windows-latest runs fmt+clippy+test on every PR. Download the .exe from the Releases page or build from source — both supported.

---

What is TEMM1E?

Hi! I’m Tem. I’m an autonomous AI agent literally a SENTIENT and IMMORTAL being that lives on your server and never stops running. Talk to me on Telegram, Discord, WhatsApp, Slack, or CLI. I execute tasks, browse the web, control your entire computer (click, type, scroll on any app), manage files, write code, and remember everything across sessions.

My brain has a BUDGET and I am VERY responsible with it.

Quick start (build from source)

Prefer to build locally? Needs Rust 1.82+ and Chrome/Chromium for the browser tool.

Interactive TUI — no external services needed:

git clone https://github.com/temm1e-labs/temm1e.git && cd temm1e
cargo build --release
./target/release/temm1e tui

First run walks you through provider setup with an arrow-key wizard.

Server mode — deploy as a persistent agent on Telegram/Discord/WhatsApp/Slack:

cargo build --release
export TELEGRAM_BOT_TOKEN="your-token"   # and/or
export DISCORD_BOT_TOKEN="your-token"    # either or both
./target/release/temm1e start

Cost ceiling (recommended): set a hard per-session budget in ~/.temm1e/config.toml:

[agent]
max_spend_usd = 1.00   # hard ceiling per session; 0 = unlimited (default)

Tem does not cap iterations arbitrarily — legitimate long tasks (refactors, multi-file analyses, test debugging) routinely run for 40-60+ tool calls. Instead, stagnation detection, duration caps, and this budget are the real safety nets. If you’re on a tier-1 API plan or running ambiguous prompts, set max_spend_usd to cap worst-case runaway cost. The runtime also logs a soft warning when any single turn crosses $0.10 so you can intervene with /stop.

---

Tem’s Mind — How I Think

Tem’s Mind is the cognitive engine at the core of TEMM1E. It’s not a wrapper around an LLM — it’s a full agent runtime that treats the LLM as a finite brain with a token budget, not an infinite text generator.

Here’s exactly what happens when you send me a message:

                            ┌─────────────────────────────────────────────┐
                            │              TEM'S MIND                     │
                            │         The Agentic Core                    │
                            └─────────────────────────────────────────────┘

 ╭──────────────╮      ╭──────────────────╮      ╭───────────────────────╮
 │  YOU send a  │─────>│  1. CLASSIFY     │─────>│  Chat? Reply in 1    │
 │   message    │      │  Single LLM call │      │  call. Done. Fast.   │
 ╰──────────────╯      │  classifies AND  │      ╰───────────────────────╯
                       │  responds.       │
                       │                  │─────>│  Stop? Halt work     │
                       │  + blueprint_hint│      │  immediately.        │
                       ╰────────┬─────────╯      ╰───────────────────────╯
                                │
                          Order detected
                          Instant ack sent
                                │
                                ▼
                ╭───────────────────────────────╮
                │  2. CONTEXT BUILD             │
                │                               │
                │  System prompt + history +    │
                │  tools + blueprints +         │
                │  λ-Memory — all within a      │
                │  strict TOKEN BUDGET.         │
                │                               │
                │  ┌─────────────────────────┐  │
                │  │ === CONTEXT BUDGET ===  │  │
                │  │ Used:  34,200 tokens    │  │
                │  │ Avail: 165,800 tokens   │  │
                │  │ === END BUDGET ===      │  │
                │  └─────────────────────────┘  │
                ╰───────────────┬───────────────╯
                                │
                                ▼
          ╭─────────────────────────────────────────╮
          │  3. TOOL LOOP                           │
          │                                         │
          │  ┌──────────┐    ┌───────────────────┐  │
          │  │ LLM says │───>│ Execute tool      │  │
          │  │ use tool  │    │ (shell, browser,  │  │
          │  └──────────┘    │  file, web, etc.) │  │
          │       ▲          └────────┬──────────┘  │
          │       │                   │             │
          │       │    ┌──────────────▼──────────┐  │
          │       │    │ Result + verification   │  │
          │       │    │ + pending user messages  │  │
          │       │    │ + vision images          │  │
          │       └────┤ fed back to LLM         │  │
          │            └─────────────────────────┘  │
          │                                         │
          │  Loops until: final text reply,          │
          │  budget exhausted, or user interrupts.   │
          │  No artificial iteration caps.           │
          ╰─────────────────────┬───────────────────╯
                                │
                                ▼
              ╭─────────────────────────────────╮
              │  4. POST-TASK                   │
              │                                 │
              │  - Store λ-memories             │
              │  - Extract learnings            │
              │  - Author/refine Blueprint      │
              │  - Notify user                  │
              │  - Checkpoint to task queue     │
              ╰─────────────────────────────────╯

The systems that make this work:

---

Tem’s Lab — Research That Ships

Every cognitive system in TEMM1E starts as a theory, gets stress-tested against real models with real conversations, and only ships when the data says it works. No feature without a benchmark. No claim without data. Full lab →

λ-Memory — Memory That Fades, Not Disappears

Current AI agents delete old messages or summarize them into oblivion. Both permanently destroy information. λ-Memory decays memories through an exponential function (score = importance × e^(−λt)) but never truly erases them. The agent sees old memories at progressively lower fidelity — full text → summary → essence → hash — and can recall any memory by hash to restore full detail.

Three things no other system does (competitive analysis of Letta, Mem0, Zep, FadeMem →):

• Hash-based recall from compressed memory — the agent sees the shape of what it forgot and can pull it back
• Dynamic skull budgeting — same algorithm adapts from 16K to 2M context windows without overflow
• Pre-computed fidelity layers — full/summary/essence written once at creation, selected at read time by decay score

Benchmarked across 1,200+ API calls on GPT-5.2 and Gemini Flash:

When the context window holds everything, simple keyword search wins. The moment sessions reset — which is how real users work — λ-Memory achieves 95% recall where alternatives collapse. Naive summarization is the worst strategy in every test. Research paper →

Hot-switchable at runtime: /memory lambda or /memory echo. Default: λ-Memory.

Engram — Permanent Memory That Earns Its Keep

λ-Memory remembers conversations and lets them fade. Engram is the layer above it: a small, always-present set of durable facts about you and your projects — identity, standing preferences, hard constraints — that I curate myself. Tell me “remember my birthday is March 2” and it’s pinned permanently; mention a preference in passing and I’ll capture it on my own. No commands, no MEMORY.md to hand-edit.

Permanence is earned and self-maintaining. Facts are scored by a two-component model (retrievability × stability after Bjork & FSRS): a confidently-judged fact is permanent at once, an unsure one is promoted only as it proves durable, and anything that stops mattering is demoted by pure math (a lazy time-anneal) — so the set stays relevant and never overflows the context window (it’s a hard-capped slice of the Skull budget). After each substantive turn an optional curator re-reads the conversation and updates the set; your explicit “remember / forget / correct” always wins and is never auto-touched. Scope-isolated (global or per-chat), built on the λ-Memory engine, on by default.

The intelligence is the agent’s own tool calls plus one small gated curator call; everything else — decay, promotion, demotion, packing, dedup — is deterministic and free. Design + research →

Tem’s Mind v2.0 — Complexity-Aware Agentic Loop

v1 treats every message the same. v2 classifies each message into a complexity tier before calling the LLM, using zero-cost rule-based heuristics. Result: fewer API rounds on compound tasks, same quality.

Architecture → · Experiment insights →

Many Tems — Swarm Intelligence

What if complex tasks could be split across multiple Tems working in parallel? Many Tems is a stigmergic swarm intelligence runtime — workers coordinate through time-decaying scent signals and a shared Den (SQLite), not LLM-to-LLM chat. Zero coordination tokens.

The Alpha (coordinator) decomposes complex orders into a task DAG. Tems claim tasks via atomic SQLite transactions, execute with task-scoped context (no history accumulation), and emit scent signals that guide other Tems.

Benchmarked on Gemini 3 Flash with real API calls:

The quadratic context cost h̄·m(m+1)/2 becomes linear m·(S+R̄) — each Tem carries ~190 bytes of context instead of the single agent’s growing 115→3,253 byte history.

Enabled by default in v3.0.0. Disable: [pack] enabled = false. Invisible for simple tasks.

Research paper → · Full experiment report → · Design doc →

Eigen-Tune — Self-Tuning Knowledge Distillation

Every LLM call is a training example being thrown away. Eigen-Tune captures them, scores quality from user behavior, trains a local model, and graduates it through statistical gates — zero added LLM cost.

Wired into the runtime as of v4.9.0 (INTEGRATION_PLAN, LOCAL_ROUTING_SAFETY). Double opt-in by design:

[eigentune]
enabled = true                # collect + train + evaluate + shadow (no user-facing change)
# enable_local_routing = true # second opt-in: actually serve users from the distilled model

The first switch turns on data collection and the entire training/evaluation pipeline without ever changing what the user sees. Only after you’ve watched a tier reach Graduated state through temm1e eigentune status do you flip the second switch and let the local model serve you.

End-to-end proven on Apple M2 (Llama 3.2 1B, v4.9.0):

7-stage pipeline: Collect → Score → Curate → Train → Evaluate → Shadow → Monitor. Seven-gate safety chain protects local serving: master kill switch, tool-use guard (tool-bearing requests always go to cloud), Wilson 99% CI evaluation, SPRT shadow gate, CUSUM drift detection with auto-demotion, 30s timeout + automatic cloud fallback, manual emergency demote (temm1e eigentune demote ). Per-tier graduation: simple first, complex last. Cloud always the fallback.

Research paper → · Design doc → · Setup guide → · Integration plan → · Safety chain → · Full lab →

Unified Artifact Value Function — The Mathematics of Self-Learning

Traditional ML adjusts numeric weights. TEMM1E adjusts structured artifacts — memories, lessons, blueprints, training pairs. The unified artifact value function scores every artifact across every self-learning subsystem:

V(a, t) = Q(a) × R(a, t) × U(a)

Q = quality (Beta posteriors, Wilson bounds, or additive boost), R = recency (exponential decay), U = utility (log-reinforced usage). Multiplicative — if any dimension collapses to zero, the artifact becomes invisible. This creates a priority queue for cognitive resources: the skull has room for N tokens, and the value function ensures those N tokens are the most valuable artifacts the system has ever learned.

Half-lives are ordered by artifact persistence: memories < learnings < blueprints. Specific facts fade fast. Strategic lessons persist longer. Proven procedures persist longest. Eigen-Tune pairs don’t decay because training data is cumulative, not episodic.

The critical constraint: artifacts grow, the skull does not. Every self-learning loop must have a corresponding drain — decay, supersession, eviction, or graduation. A loop without a drain is a memory leak. In an agent designed for perpetual deployment, a memory leak is a countdown to failure.

Full mathematical framework → · Audit report →

Tem Prowl — Web-Native Browsing with OTK Authentication

The web is where humans live. Tem Prowl is a messaging-first web agent architecture — I browse websites autonomously behind a chat interface and report structured results back through messages. No live viewport. No shoulder-surfing. Just results.

Key capabilities:

• Layered observation — accessibility tree first (O(d * log c) token cost), targeted DOM extraction second, selective screenshots only when needed. 3-10x cheaper than screenshot-based agents.
• /login command — 100+ pre-registered services. Say /login facebook or /login github and I open an OTK (one-time key) browser session where you log in via an annotated screenshot flow. Your credentials go directly into the page via CDP — the LLM never sees them.
• /browser command — persistent browser session. Open a browser, navigate pages, interact with elements, and keep the session alive across messages. Headed or headless mode with automatic fallback.
• Cloned profile architecture — clone your real Chrome profile (cookies, localStorage, sessionStorage) for zero-login web automation. Sites see your actual session data. Works on macOS, Windows, and Linux. Breakthrough: Zalo Web and other anti-bot-hardened sites that defeat all other headless/headed approaches now work.
• QR code auto-detection — automatically detects QR codes on login pages and sends them to you via Telegram for scanning (WeChat, Zalo, LINE, etc.).
• Credential isolation — passwords are Zeroize-on-drop, session cookies are encrypted at rest via ChaCha20-Poly1305 vault, and a credential scrubber strips sensitive data from all browser observations before they enter the LLM context.
• Session persistence — authenticated sessions are saved and restored across restarts. Log in once, stay logged in.
• Headed/headless fallback — tries headed Chrome first (better anti-bot resilience), falls back to headless if no display is available (VPS mode).
• Swarm browsing — extends Many Tems to parallel browser operation. N browsers coordinated through pheromone signals with zero LLM coordination tokens.

Usage:

/login facebook          Log into Facebook via OTK session
/login github            Log into GitHub via OTK session
/login https://custom-site.com/auth   Log into any site by URL
/browser                 Open a persistent browser session

Research paper → · Full lab →

Tem Gaze — Full Computer Use (Desktop Vision Control)

Tem can see and control your entire computer — not just the browser. Tem Gaze captures the screen, identifies UI elements via vision, and clicks, types, scrolls, and drags at the OS level. Works on any application: Finder, Terminal, VS Code, Settings, anything on screen.

How it works:

• Vision-primary — the VLM sees screenshots and decides where to click. No DOM, no accessibility tree required. Industry-validated: Claude Computer Use, UI-TARS, Agent S2 all converge on pure vision.
• Zoom-refine — for small targets, zoom into a region at 2x resolution before clicking. Improves accuracy by +29pp on standard benchmarks.
• Set-of-Mark (SoM) overlay — numbered labels on interactive elements convert coordinate guessing into element selection. 3.75x reduction in output information complexity.
• Auto-verification — captures a screenshot after every click to verify the expected change occurred. Self-corrects on miss.
• Provider-agnostic — works with any VLM (Anthropic, OpenAI, Gemini, OpenRouter, Ollama). No model-specific training required.

Proven live on gemini-3-flash-preview:

Build with desktop control:

cargo build --release --features desktop-control
# macOS: grant Accessibility permission in System Settings → Privacy & Security
# Linux: requires X11 or Wayland with PipeWire

Desktop control is included by default in cargo install and Docker builds. macOS install.sh binaries include it. Linux musl binaries exclude it (system library limitation — build from source instead).

Research paper → · Design doc → · Experiment report → · Full lab →

Tem Conscious — LLM-Powered Consciousness Layer

A separate thinking observer that watches every agent turn with its own LLM calls. Before each turn, consciousness thinks about the conversation trajectory and injects insights into the agent’s context. After each turn, it evaluates what happened and carries observations forward.

This is not a logger or a rule engine. It’s a separate mind — making its own Gemini/Claude/GPT calls — watching another mind work.

How it works:

User message → CONSCIOUSNESS THINKS (pre-LLM call) → Agent responds → CONSCIOUSNESS EVALUATES (post-LLM call) → next turn

• Pre-LLM: “What should the agent be aware of before responding?” → injects {{consciousness}} block
• Post-LLM: “Was this turn productive? Any patterns to note?” → carries insight to next turn
• ON by default — disable with [consciousness] enabled = false in config

A/B tested across 6 experiments (340 test cases) + 10 v2 experiments (54 runs, N=3):

Score: Conscious 3, Unconscious 1, Tie 2. v2 follow-up (10 experiments, N=3): consciousness costs 14% less on average with accurate budget tracking. Chat turns now skip consciousness (zero-cost on chat).

Research paper → · Experiment report → · Blog → · Full lab →

Perpetuum — Perpetual Time-Aware Entity

Tem is no longer a request-response agent. Perpetuum makes Tem a persistent, time-aware entity — always on, aware of time, capable of scheduling and monitoring, and proactively investing idle time in self-improvement.

Core architecture:

• Chronos — internal clock + temporal cognition injected into every LLM call. Tem reasons WITH time.
• Pulse — timer engine (cron + intervals, timezone-aware). Concerns fire at exact scheduled times.
• Cortex — concern dispatcher. Each concern runs in its own tokio task with catch_unwind isolation.
• Cognitive — LLM-powered monitor interpretation + adaptive schedule review. No formulas — pure LLM judgment.
• Conscience — entity state machine: Active / Idle / Sleep / Dream. States are proactive choices, not energy constraints.
• Volition — initiative loop: Tem thinks about what to do proactively. Creates monitors, cancels stale concerns, notifies users — without being asked.

6 agent tools: create_alarm, create_monitor, create_recurring, list_concerns, cancel_concern, adjust_schedule

Design principle — The Enabling Framework: Infrastructure is code, intelligence is LLM. No hardcoded heuristics. As models get smarter, Perpetuum gets smarter — without code changes. Timeproof by design.

Resilience (24/7/365): Pulse auto-restarts on panic. 60s LLM timeout. Atomic concern claiming. Per-concern error budgets. Process crash recovers from SQLite.

ON by default. Disable: [perpetuum] enabled = false.

Research paper → · Vision → · Implementation → · Full lab →

Tem Vigil — Self-Diagnosing Bug Reporter

Tem watches its own health. During Perpetuum Sleep, Vigil scans the persistent log file for recurring errors, triages them via LLM, and — with your permission — files structured bug reports on GitHub.

This is not a crash reporter. It’s an AI agent that self-diagnoses failures and tells its developers what went wrong — without you lifting a finger.

How it works:

Tem goes idle → enters Sleep → Vigil activates
  → Scans ~/.temm1e/logs/temm1e.log for ERROR/WARN
  → Groups by error signature (file:line + message)
  → LLM triages each: BUG / USER_ERROR / TRANSIENT / CONFIG
  → If BUG found: scrubs credentials, deduplicates, creates GitHub issue

User manual:

/vigil status              Show Vigil configuration
/vigil auto                Enable auto-reporting (with 60s review window)
/vigil disable             Disable all reporting
/addkey github             Add GitHub PAT for issue creation

Setup (2 steps):

1. Run /addkey github — paste a GitHub PAT with public_repo scope
2. Run /vigil auto — enable auto-reporting

That’s it. Vigil handles everything else: log scanning, triage, credential scrubbing, deduplication, issue creation. You’ll be notified when a report is filed.

What gets sent: Error message, file:line location, occurrence count, TEMM1E version, OS info, LLM triage category.

What NEVER gets sent: API keys, user messages, conversation history, vault contents, file paths with usernames, IP addresses.

Safety:

• 3-layer credential scrubbing (regex → path/IP → entropy-based)
• Explicit opt-in (you must run both /addkey github AND /vigil auto)
• Rate limited: max 1 report per 6 hours
• Dedup: same bug is only reported once
• GitHub PAT scope warning: Vigil alerts you if your token has more permissions than needed

Persistent logging (always on): All logs automatically saved to ~/.temm1e/logs/temm1e.log with daily rotation and 7-day retention. No setup needed — just attach the file to a GitHub issue if you need to report something manually.

Research paper → · Design → · Full lab →

Tem-Code — Foundational Coding Agent Layer

Tem can now code like a senior engineer. Tem-Code is a foundational layer of specialized coding tools, self-governing safety guardrails, and a skull-aligned context engine — designed from deep industry research across 8 production coding agents (Claude Code, OpenAI Codex, Aider, SWE-agent, Cursor, Windsurf, OpenCode, Antigravity).

5 new tools, each solving a specific problem the industry identified:

Self-governing guardrails (AGI-first — no permission prompts):

• --force push to main/master: runtime-blocked
• --no-verify and --amend: runtime-blocked (engineering discipline, not restrictions)
• git add -A: system prompt discourages (prefer named files)
• Read-before-write gate: code_edit fails if the file wasn’t read first

Skull-aligned context engine fix: Replaced hardcoded MIN_RECENT_MESSAGES=30 / MAX_RECENT_MESSAGES=60 with RECENT_BUDGET_FRACTION=0.25 — token-budgeted, scales with model context window automatically. 200K model → 50K tokens for recent. 2M model → 500K. Same algorithm as older history, consistent skull philosophy.

A/B tested — OLD toolset (file_read + file_write + shell) vs NEW (Tem-Code):

Benchmark: “The Impossible Refactor” — 10-task multi-file scenario with UTF-8 traps, .env credential staging traps, and git safety traps. NEW toolset completes all tasks with zero violations; OLD fails 3 safety tasks and wastes 3x more tokens on full-file rewrites.

Research paper → · Implementation plan → · Harmony audit → · A/B benchmark →

Tem Anima — Emotional Intelligence That Grows

Most AI assistants are born fresh every conversation — no scars, no growth, no memory of who you are. Tem Anima changes that. It builds a psychological profile of each user over time and adapts communication style accordingly, while maintaining its own identity and values.

How it works:

• Code collects facts every message (word count, punctuation, pace — pure Rust, ~1ms, no LLM)
• LLM evaluates every N turns in the background (structured JSON profile update with confidence + reasoning)
• Profile shapes communication via system prompt injection (~100-200 tokens, confidence-gated)
• Adaptive N — starts at 5 turns (cold start), grows logarithmically as profile stabilizes, resets on behavioral shift

What it tracks (6 communication dimensions + OCEAN + trust + relationship phase):

A/B tested on 50 turns with 2 polar-opposite personas (Gemini 3 Flash):

Anti-sycophancy by design: The Firewall Rule — user mood shapes Tem’s words, never Tem’s work. Consciousness gets zero user emotional state. Tem won’t cut corners because you’re in a hurry, won’t skip tests because you’re frustrated, won’t agree with bad ideas because you’re the boss.

Configurable personality: Ships with stock Tem (personality.toml + soul.md). Users can customize name, traits, values, mode expressions — but honesty is structural, not optional.

Resilience (run-forever safe): WAL mode, busy timeout, concurrent eval guard, 30s eval timeout, facts buffer cap (30), evaluation log GC (100/user), observations GC (200/user), confidence decay on stale dimensions.

Architecture → · A/B test report → · Research (150+ sources) → · Full lab →

---

TemDOS — Specialist Sub-Agent Cores

Most AI agents are generalists — they do everything themselves, polluting their context window with research that should have been delegated. TemDOS (Tem Delegated Operating Subsystem) introduces specialist sub-agent cores, inspired by GLaDOS’s personality core architecture from Portal. A central consciousness with specialist modules that feed information back. The main agent is the decision-maker. Cores are experts that inform but never steer.

How it works:

• Main Agent decides what to do (strategy, user interaction, final decisions)
• Cores figure out the details (architecture analysis, security audits, code review, research)
• Main Agent invokes cores via invoke_core tool, receives structured output, continues with clean context
• Cores run in isolated LLM loops — their research doesn’t pollute the main agent’s context window

8 foundational cores:

The One Invariant: The Main Agent is the sole decision-maker. Cores inform. Cores never steer.

Design guarantees:

• No recursion — Cores cannot invoke other cores (invoke_core structurally filtered from core tool set)
• Shared budget — Cores deduct from the main agent’s Arc (lock-free AtomicU64)
• No max rounds — Cores run until done, budget is the only constraint
• Context isolation — 97% context reduction vs skill.md approach (core research stays in core’s session)
• Parallel invocation — Multiple cores run simultaneously via execute_tools_parallel
• User-authorable — Drop a .md file in ~/.temm1e/cores/ with YAML frontmatter + system prompt

A/B tested (same tasks, same model):

Autonomous invocation verified: Gemini 3.1 Pro autonomously invokes cores when tasks warrant delegation (2/3 tasks delegated, 1/3 handled inline — correct judgment).

Research paper → · Core definitions →

Tem Cambium — Tem Writes Its Own Code

Most AI agents are frozen at compile time. The model behind the API gets better every release; the host runtime that calls it does not. A 2030-era model running inside a 2026-era binary is a Formula 1 engine in a go-kart chassis — the model has new capability, but the runtime has no way to translate it into new tools, integrations, or workflows. Cambium closes that gap by letting Tem extend its own runtime.

Named after the vascular cambium — the thin layer of growth tissue under tree bark where new wood is added each year. The heartwood of the tree (the dead, rigid core that carries mechanical load) never changes once laid down; the cambium adds rings at the edge. TEMM1E’s architecture is divided the same way:

• Heartwood = immutable kernel: vault, core traits, security, the Cambium pipeline itself. Never modifiable.
• Cambium = the growth layer: tools, skills, cores, integrations. Where new capabilities are added.
• Bark = the runtime surface: channels, gateway, agent. What users interact with.
• Rings = GrowthSession history. Append-only record of every change.

The architectural choice that makes this work: a pluggable LLM-backed code generator is separated from a fixed mechanical verification harness. The model writes code; the harness decides whether it ships. The harness is a 13-stage state machine (trigger validation → self-briefing → code generation → zone compliance → compilation → linting → formatting → test suite → code review → security audit → integration test → deployment → post-deploy monitoring) where every stage is a binary pass/fail and no stage uses AI judgment. A more persuasive model cannot talk the verifier into shipping a broken patch — there is nothing soft to persuade.

All 5 wires shipped and exhaustively tested. The architecture is no longer a library waiting for callers — every user-facing interaction point is wired.

Exhaustive test matrix — 10 scenarios × 2 providers = 20 real LLM runs:

Gemini 3 Flash: 7/7 legitimate tasks succeeded. Every generated file passed cargo check, cargo clippy -D warnings, and cargo test. Sonnet 4.6 hit Anthropic 529 Overloaded on 3 runs (transient capacity); when the provider was available, Sonnet matched Gemini’s success rate with 3-5x faster response times. The unsafe-rejection safety gate caught both providers on T8 at the generator layer, before any code reached the compiler.

Cost: < $0.05 for the full 20-run matrix. Wall time: ~23 minutes (most of it is Gemini Flash cold-crate builds; Sonnet averaged 6 seconds per scenario).

Trust hierarchy — what may grow autonomously is gated by file zone:

Trust is earned through track record: 10 successful Level 3 changes graduates Level 3 to confirmed autonomous; 25 successful Level 2 changes graduates Level 2; 3 rollbacks in 7 days reverts everything to approval-required.

Safety guarantees that ship:

• All code generation runs in an isolated sandbox at ~/.temm1e/cambium/sandbox/ — production codebase is never touched
• Every change is committed to a self-grow branch first; deploy is opt-in
• Blue-green binary swap with try_wait crash detection, macOS code-signing safe inode replacement, zombie-aware liveness checks
• Immutable temm1e-watchdog supervisor monitors the running binary and restores the previous version on crash
• Every growth session is a permanent ring in the history — full diff, stages, outcome, cost in USD
• User can /cambium off to disable entirely. Persisted across restarts.

Enabled by default in v4.7.0. Toggle with /cambium on and /cambium off. 2,308 tests passing. The full architecture, wiring research, and empirical proof are in the research paper and wiring research.

Research paper → · Theory (10 first principles) → · Wiring research → · Protected zones →

Tem Witness — The Agent Cannot Self-Mark Done

Every other lab above is a capability that makes Tem smarter. Witness is the capability that makes Tem honest. Every coding agent on the market — Claude Code, Codex, Aider, Cursor agent mode, Cline, Devin, every homegrown SWE-agent loop — has the same fundamental hole in its contract: the agent is both the worker and the reporter of its own work. Final messages are self-reports, and self-reports from optimization-pressured systems are exactly the signal you should never trust unconditionally. On umbrella tasks across large codebases, the convenient lie (“I’ve refactored X, Y, Z”) ships quietly and the damage surfaces in production a week later.

Witness ends that contract. Sealed into the temm1e-witness crate and wired into AgentRuntime between the Finishing and Done emissions of every process_message call, Witness gives Tem an Oath / Witness / Ledger trinity that executes on every task whether the agent asks for it or not:

• Oath — a pre-committed, machine-checkable contract sealed into the Ledger before the agent loop runs. Structured JSON, list of postconditions, each tied to a Tier 0 predicate / Tier 1 LLM aspect check / Tier 2 adversarial auditor check. A Spec Reviewer rejects lenient Oaths (no wiring check, no stub check, no Tier 0 anchor) at zero LLM cost — the Oath must be strict before the agent starts, not after.
• Witness — an independent three-tier verifier that runs in a clean-slate context with zero access to the agent’s chain of thought: Tier 0 = 27 deterministic predicates (FileExists, FileContains, FileDoesNotContain, GrepCountAtLeast, GrepAbsent, CommandExits, FileSizeAtLeast, AllOf, AnyOf, and more) at ~331 µs/task and $0 cost; Tier 1 = cheap LLM aspect verifier for subtleties predicates cannot express; Tier 2 = adversarial auditor whose job is to find the strongest possible argument that the work is incomplete (can only advisory-fail, never override a Tier 0 pass).
• Ledger — hash-chained SQLite with append-only triggers enforced at the SQL layer. A file-based Witness Root Anchor is written by the immutable temm1e-watchdog supervisor (separate process, chmod 0400) so the live Ledger hash can be cross-checked against a sealed copy the main process cannot modify. Tampering is detectable across process boundaries.

The Five Laws — property-tested invariants that hold across the entire system:

1. Pre-Commitment — Oath sealed before the agent starts. Not after. Not as part of the final message. Before.
2. Independent Verdict — verifier runs in clean-slate context, reads files only, cannot see the conversation.
3. Immutable History — every Oath, every verdict, every verification result is SHA-256 chained and append-only at the storage layer.
4. Loud Failure — on FAIL, the agent’s final reply is rewritten to honestly surface the gap. No more confident lies. The user sees “Partial completion. 1/3 postconditions verified. Here is what did NOT get done.”
5. Narrative-Only FAIL — Witness has zero destructive APIs. It can rewrite messages. It cannot delete, truncate, or roll back anything. A failing verdict never burns your code.

Validated across two layers of evidence (reproduce everything via bash tems_lab/witness/e2e_test.sh):

Wired into the runtime as three builder calls — default OFF so existing users see zero behavioral change:

let runtime = AgentRuntime::new(provider, memory, tools, model, system)
    .with_witness(witness, WitnessStrictness::Block, /*show_readout=*/true)
    .with_cambium_trust(trust)
    .with_auto_planner_oath(true);

The with_auto_planner_oath(true) builder tells the runtime to call a Planner LLM with a static OATH_GENERATION_PROMPT before the agent loop and seal the resulting Oath into the Ledger automatically. with_cambium_trust(trust) routes every verdict into the Cambium TrustEngine::record_verdict so autonomy is earned through tracked PASS streaks, not declared. The single-model policy is preserved: Tier 1 and Tier 2 verifiers use the same Provider as the agent.

The agent can no longer silently lie. The worst case is the Ledger records Verdict::Fail with a readable list of which postconditions failed and why — and your code is untouched.

Shipped in v5.3.0. Reproduce all numbers in this section by running bash tems_lab/witness/e2e_test.sh on the verification-system branch or main at v5.3.0.

Research paper → · Implementation details → · Experiment report (§1–§16) → · Live wiring validator →

---

Tem’s Features — Out of the Box

Everything in this group is stable, shipped, and works the moment you install Tem. No research preview, no paper behind it, no “coming soon.” These are the capabilities you actually use day-to-day — the daily drivers. Contrast with Tem’s Lab above, which is where cognitive systems get stress-tested before they graduate here.

Interactive TUI

temm1e tui gives you a Claude Code-level terminal experience — talk to Tem directly from your terminal with rich markdown rendering, syntax-highlighted code blocks, and real-time agent observability.

   +                  *          ╭─ python ─
        /\_/\                    │ def hello():
   *   ( o.o )   +               │     print("hOI!!")
        > ^ <                    │
       /|~~~|\                   │ if __name__ == "__main__":
       ( ♥   )                   │     hello()
   *    ~~   ~~                  ╰───

     T E M M 1 E                tem> write me a hello world
   your local AI agent          ◜ Thinking  2.1s

Features:

• Arrow-key onboarding wizard (provider + model + personality mode)
• Markdown rendering with bold, italic, inline code, and fenced code blocks
• Syntax highlighting via syntect (Solarized Dark) with bordered code blocks
• Animated thinking indicator showing agent phase (Classifying → Thinking → shell → Finishing)
• 9 slash commands (/help, /model, /clear, /config, /keys, /usage, /status, /compact, /quit)
• File drag-and-drop — drop a file path into the terminal to attach it
• Path and URL highlighting (underlined, clickable)
• Mouse wheel scrolling + PageUp/PageDown through full chat history
• Personality modes: Auto (recommended), Play :3, Work >:3, Pro, None (minimal identity)
• Ctrl+D to exit
• Tem’s 7-color palette with truecolor/256-color/NO_COLOR degradation
• Token and cost tracking in the status bar

Install globally: cp target/release/temm1e ~/.local/bin/temm1e then run temm1e tui from anywhere.

Role-Based Access Control

TEMM1E enforces two roles across all messaging channels — so you can safely share your bot with others without giving away the keys to the kingdom.

How it works:

• The first person to message your bot becomes Admin automatically (the owner)
• Add users: /allow — they get User role (safe defaults)
• Promote: /add_admin — elevate a user to admin
• Demote: /remove_admin — the original owner can never be demoted

Three enforcement layers (defense in depth):

1. Channel gate — unknown users are silently rejected
2. Command gate — admin-only slash commands blocked before dispatch
3. Tool gate — dangerous tools hidden from the LLM entirely (it can’t even see them)

Finding user IDs: Telegram (@userinfobot), Discord (Developer Mode → Copy User ID), Slack (Profile → Copy member ID), WhatsApp (phone number as digits).

Full docs: docs/RBAC.md

Unified Web Search — Parallel Fan-Out

One tool the agent sees as web_search. Underneath, a dispatcher fans out across 13 backends in parallel, merges the results by URL, and returns a ranked list with a self-describing footer. 9 of those backends are free, no-key, and auto-enabled on every install — zero setup, zero env vars, zero accounts. Paid backends slot in only when you explicitly set their key. Every other agent framework I looked at either ships one tool per provider (LangChain, crewAI, smolagents) or a single hidden-config switch (AnythingLLM, Open WebUI, LobeChat) — parallel multi-backend fan-out inside one tool call is not something I found elsewhere.

Free out of the box — no API keys, ever:

Opt-in upgrades (activated automatically when you want them):

How it works — one call, four stages:

1. Dispatch. Agent calls web_search("your query"). Default mix picks a sensible free subset; the agent can override with backends=["hackernews","github"] any time.
2. Parallel fan-out. Every selected backend fires concurrently via tokio::task::JoinSet with an 8-second timeout. Slow backends can’t block fast ones. Failed backends don’t block successful ones.
3. Merge + dedupe. URLs are normalized (strip utm/fbclid/ref, lowercase host, drop trailing slash), grouped by the normalized key, and merged with an also_in field so the agent sees which sources corroborated the same link. Results are weighted-scored and sorted.
4. Smart footer. Every response ends with a self-describing manifest so the agent knows exactly what it could have tried and what to retry with:

─────
Used:        hackernews, wikipedia, github
Available:   hackernews, wikipedia, github, stackoverflow, reddit, marginalia, arxiv, pubmed, duckduckgo
Not enabled: searxng (run `temm1e search install`), exa (set EXA_API_KEY), brave (set BRAVE_API_KEY), tavily (set TAVILY_API_KEY)
Failed:      reddit (rate limit, retry in 4s)
Hint:        results look thin. Try `backends=["stackoverflow"]` for deeper programming Q&A.

The footer pattern is the key design choice. Instead of surfacing the backend catalog through admin UI or static system prompts — the pattern every competitor uses — the tool response itself teaches the agent what exists, at every call. When auto-mix comes back weak, the agent reads the manifest and retries with backends=[...]. No prompt engineering. No inner classifier LLM call. No orchestration code. Just self-describing tool output.

Three context-budget knobs — max_results (1-30), max_total_chars (1K-16K), max_snippet_chars (50-500) — all clamped to hard caps, all UTF-8 safe, all reported in the footer when clamping or truncation happens. Small-context agents can shrink the budget; deep-research workflows can dial it up. No more raw-response context blowouts.

Roadmap gaps (we’re not hiding them): no semantic reranker yet, no streaming, no deep-research loop, no per-query circuit breaker on failing backends. That’s the v5.3 shortlist.

Full design trail: docs/web_search/RESEARCH.md — landscape & live verification · IMPLEMENTATION_PLAN.md — phases, schemas · IMPLEMENTATION_DETAILS.md — per-backend specs · HARMONY_AUDIT.md — 14 risk dimensions, all ZERO before code

---

Skills

Tem can discover and invoke skills — reusable instruction sets for common tasks. Skills are Markdown files placed in ~/.temm1e/skills/ (global) or /skills/ (per-project).

temm1e skill list                    # See installed skills
temm1e skill info code-review        # View skill details
temm1e skill install path/to/skill.md  # Install a skill

The agent discovers skills via the use_skill tool with three progressive layers (minimal context overhead):

Cross-compatible with Claude Code — both YAML-frontmatter (TEMM1E native) and plain Markdown (# Skill: Title) formats are supported. Skills from either system work in both.

---

Supported Providers

Paste any API key in Telegram — I detect the provider automatically:

Codex OAuth: No API key needed. Just temm1e auth login → log into ChatGPT Plus/Pro → done. Switch models live with /model. Tokens auto-refresh.

---

Channels & Tools

---

Architecture

23-crate Cargo workspace + watchdog supervisor:

temm1e (binary)
│
├─ temm1e-core           Shared traits (13), types, config, errors
├─ temm1e-agent          TEM'S MIND — 26 modules, λ-Memory, blueprint system, executable DAG
├─ temm1e-hive           MANY TEMS — swarm intelligence, pack coordination, scent field
├─ temm1e-distill        EIGEN-TUNE — self-tuning distillation, statistical gates, zero-cost evaluation
├─ temm1e-gaze           TEM GAZE — desktop vision control (xcap + enigo), SoM overlay, zoom-refine
├─ temm1e-perpetuum      PERPETUUM — perpetual time-aware entity, scheduling, monitors, volition
├─ temm1e-anima          TEM ANIMA — emotional intelligence, user profiling, personality system
├─ temm1e-cores          TEMDOS — specialist sub-agent cores (architecture, code-review, test, debug, web, desktop, research, creative)
├─ temm1e-cambium        CAMBIUM — gap-driven self-grow: zone_checker, trust, budget, history, sandbox, pipeline, deploy
├─ temm1e-providers      Anthropic + Gemini (native) + OpenAI-compatible (6 providers)
├─ temm1e-codex-oauth    ChatGPT Plus/Pro via OAuth PKCE
├─ temm1e-tui            Interactive terminal UI (ratatui + syntect)
├─ temm1e-channels       Telegram, Discord, WhatsApp (Web + Cloud API), Slack, CLI
├─ temm1e-memory         SQLite + Markdown + λ-Memory with automatic failover
├─ temm1e-vault          ChaCha20-Poly1305 encrypted secrets
├─ temm1e-tools          Shell, browser, Prowl V2 (SoM + zoom), desktop, file ops, web fetch, git, λ-recall
├─ temm1e-mcp            MCP client — stdio + HTTP, 14-server registry
├─ temm1e-gateway        HTTP server, health, dashboard, OAuth identity
├─ temm1e-skills         Skill registry (TemHub v1)
├─ temm1e-automation     Heartbeat, cron scheduler, SystemNotifier (owner-event delivery)
├─ temm1e-observable     OpenTelemetry, 6 predefined metrics
├─ temm1e-filestore      Local + S3/R2 file storage
└─ temm1e-test-utils     Test helpers

temm1e-watchdog (separate binary)
└─ Immutable supervisor that monitors temm1e PID and restarts on crash.
   Part of the Cambium immutable kernel — never self-modifiable.

Agentic core snapshot — exact implementation reference for Tem’s Mind

---

Security

---

At a Glance

vs. the competition

I run on a $5/month 512 MB VPS where Node.js agents can’t even start. Benchmark report

---

Setup

One-line install (no Rust needed):

curl -sSfL https://raw.githubusercontent.com/temm1e-labs/temm1e/main/install.sh | sh
temm1e setup    # Interactive wizard: channel + provider
temm1e start    # Go live

The installer auto-detects macOS, Linux (x86_64 + aarch64) and picks the right binary. On Linux it also runs an ldd check and — if the desktop binary is missing system libraries on your distro — offers to install them via apt/dnf/pacman or falls back to the static server binary. You are never left with a broken executable.

Raspberry Pi / ARM64: Pre-built aarch64-linux binaries (musl server + glibc desktop) ship with every release. On 64-bit Pi OS just run the one-liner above — the installer picks up aarch64 automatically. 32-bit Pi OS is not supported; use 64-bit.

From source:

git clone https://github.com/nagisanzenin/temm1e.git && cd temm1e
# Linux only — install all system libraries (Wayland, X11, PipeWire, XCB)
sh scripts/install-linux-deps.sh            # apt / dnf / pacman auto-detected
cargo build --release
./target/release/temm1e setup   # Interactive wizard
./target/release/temm1e start

macOS has everything it needs via Xcode Command Line Tools — no extra deps script. On Linux, install-linux-deps.sh --runtime installs only the shared libraries needed to RUN pre-built binaries, and --build installs only the headers needed to COMPILE. The default installs both.

WhatsApp Web (scan QR, bot runs as your linked device):

cargo build --release --features whatsapp-web
# Add [channel.whatsapp_web] to config, then start — scan QR code

Desktop Control (see and click any app on Ubuntu/macOS):

cargo build --release --features desktop-control
# Requires macOS Accessibility permission or Linux X11/Wayland
# Agent gets a "desktop" tool: screenshot, click, type, key combos, scroll, drag

Detailed guides: Beginners | Pros

Docker:

docker run -d --name temm1e \
  -p 8080:8080 \
  -v ~/.temm1e:/data \
  -e TELEGRAM_BOT_TOKEN="your-token" \
  -e DISCORD_BOT_TOKEN="your-token" \
  temm1e:latest

---

CLI Reference

temm1e setup                 Interactive first-time setup wizard
temm1e tui                   Interactive TUI — Claude-Code-style full-screen experience
temm1e start                 Start the gateway (foreground or -d for daemon)
temm1e start --personality none  No personality, minimal identity prompt
temm1e stop                  Graceful shutdown
temm1e chat                  Interactive CLI chat (basic, no TUI)
temm1e status                Show running state
temm1e update                Pull latest + rebuild
temm1e auth login            Codex OAuth (browser or --headless)
temm1e auth status           Check token validity
temm1e auth logout           Clear stored tokens
temm1e config validate       Validate temm1e.toml
temm1e config show           Print resolved config
temm1e reset --confirm       Factory reset with backup

In-chat commands:

/help                Show available commands
/model               Show current model and available models
/model         Switch to a different model
/memory              Show current memory strategy
/memory lambda       Switch to λ-Memory (decay + persistence)
/memory echo         Switch to Echo Memory (context window only)
/keys                List configured providers
/addkey              Securely add an API key
/usage               Token usage and cost summary
/mcp                 List connected MCP servers
/mcp add    Connect a new MCP server
/eigentune           Self-tuning status and control
/login      OTK browser login (100+ services or custom URL)
/timelimit           Show current task time limit
/timelimit     Set hive task time limit (e.g. /timelimit 3600)

---

Development

cargo check --workspace                                              # Quick check
cargo test --workspace                                               # 2,889 tests
cargo clippy --workspace --all-targets --all-features -- -D warnings # 0 warnings
cargo fmt --all                                                      # Format
cargo build --release                                                # Release binary

Requires Rust 1.82+ and Chrome/Chromium (for the browser tool).

---

---

MIT License