One program. No magic.

1. 01

   One program, always on.

   Smartopol runs as a single background service on your machine. Every front-end — terminal, Discord, Telegram, web, external tools — talks to the same brain. One memory, many doors in.

2. 02

   Memory Pyramid is the brain.

   A hierarchical memory that organizes itself as you use it. All conversations, all channels, all users. One local file on your disk. Sub-100ms recall across millions of tokens.

3. 03

   Context is built in layers.

   What never changes (tools, abilities), what changes slowly (who you are), and what changes every turn (this moment's recall) are kept separate. Big practical benefit: roughly half the input-token bill compared with a naïve agent.

4. 04

   Every night, the agent dreams.

   A bounded reflection job consolidates the day's memory, promotes what mattered, prunes noise, updates the user profile. Budget-tracked, auditable, opt-out-able.

5. 05

   Nothing here is a black box.

   Every tool call is written to a tamper-evident audit log. Every night's reflection writes a dated receipt you can read. Every plugin runs in a sandbox and must declare what it touches. You own the data, the log, and the keys.

Level N     [Meta-summaries]           ← Cross-topic patterns, lifetime insights
                 │
Level 2     [Domain Summaries]         ← "Work projects", "Home automation"
                 │
Level 1     [Topic Summaries]          ← "The X project", "Recipe preferences"
                /│\
Level 0  [Chunks] [Chunks] [Chunks]  ← Raw conversation fragments

Three operations keep the pyramid alive.

Recall — hybrid, not naïve.

1. Exact matches run instantly — for names, dates, the precise word you used.
2. Meaning matches run in parallel — for “that thing we talked about last week,” even if you phrase it differently today.
3. Both scored together — a result that wins on both wins big. No either/or.
4. All levels at once — a single recall can pull a raw sentence and the summary that explains it.
5. Hot cache for queries you hit often. Hot path: 10–15ms.

Why bother separating them? Because the two that don't change each turn can be reused by your LLM provider instead of re-charged for. Practical result: roughly half the input-token bill a naïve agent would rack up.

The service runs an actor-model session system. Actors communicate by message passing — no shared mutable state. Documented as a live spec — every behavior change lands in the same diff as the code.

• ▸ Crash isolation — one bad session cannot take down another
• ▸ Backpressure — per-session queue depth, visible in smartopol sessions list
• ▸ Hot reload — config changes apply to new actors without killing existing ones
• ▸ Multi-user fairness — per-user rate limits, admin multipliers, guest caps

You configure an ordered list of models you're willing to use — a primary, a fallback, a local last-resort. When the primary hits a rate limit, the next one takes over. When an API key runs out of money, the agent parks that provider for a longer cool-down (somebody forgot to pay the bill). When the primary comes back, it reclaims the top slot.

The important part: the conversation is shared. Whichever model is answering this turn sees the full history — not a fresh start, not a summary. Failovers are invisible.

One agent. Five places people can reach it today (Discord, Telegram, web, built-in terminal, direct API). Slack and WhatsApp on the roadmap. Each channel is a thin translator between the platform and the same underlying brain.

A user paired across Discord and Telegram is one identity with two inbound doors. The agent remembers what was said on Discord when the same person pings on Telegram.

Every plugin you install runs in a locked-down sandbox with a fixed memory limit, no access to your filesystem, and no network unless it declared it upfront. If a plugin wants to read your email inbox, you see that before it runs — not after.

• Declared permissions — each plugin lists what it needs. Nothing implicit.
• Signed releases — third-party plugins ship cryptographically signed. A tampered plugin won't load.
• Static scan — every plugin is checked for known-dangerous patterns before first run. Flagged ones are blocked by default.
• No ambient trust — a plugin can't phone home or touch a file you didn't hand it.

An append-only log in your data folder records every tool call, who asked for it, what arguments were used (secrets redacted), and the result. Each entry is cryptographically linked to the one before it — nobody can quietly delete or edit a line without breaking the chain.

A built-in verify command walks the log and reports the first break it finds. In regulated contexts — healthcare, legal, finance — you can prove the agent's behavior matches an independently captured timeline.

Run smartopol update and the agent checks for a new version, downloads it, verifies it's a legitimate signed release, swaps itself atomically, and keeps your conversation alive across the restart.

• · No package manager required
• · No sudo required
• · Updates come from a static, vendor-neutral location — not tied to any single code-hosting service
• · The agent won't accidentally kill itself during an update. By design.