💰 Save 50-150× Tokens with ViBo

⚡ Cheap token. Pay less. Same AI.

Persistent memory for AI agents — cuts token costs by 50-150× on every request.

ViBo gives AI agents and bots persistent memory: facts are saved between sessions, found by meaning, and protected by L1/L2/L3 encryption. Instead of loading ALL memory into every prompt, the agent retrieves only the relevant facts — so you pay for what you use, not for everything you know.

⚡ The headline number

Measured on real data. Not estimated.

Why ViBo

Agents forget everything between sessions. Every conversation starts from zero:

• "Who is this client again?"
• "What did we agree on last week?"
• "Which API keys does this project use?"

ViBo fixes that. It's memory that actually works:

🎥 Demo

📥 Get it

Try free for 2 days — the skill comes with a built-in trial key, no manual activation:

Then: unpack → python3 check_license.py → it works. After 2 days pay $5/month (Stars or USDT) — the same key extends, memory is kept.

Full license: $5/month — one key = one machine (renewable).

What you get

• Persistent memory — your agent remembers between sessions
• Semantic search — ask "what did I discuss with Anna?" and get the right facts
• Three encryption tiers:
  • L1 (Public) — visible to agent and LLM: names, tags, general knowledge
  • L2 (Private) — encrypted with the agent key: notes, plans, roadmaps
  • L3 (Secret) — encrypted with your password: API keys, credentials. Never reaches the LLM — only a 🔒 placeholder
• Portable — memory lives in one .web file. Backup = one copy command
• 50+ languages — write facts in your language, ViBo understands
• Works with any agent — Hermes, OpenClaw, LangChain, or your own (see INSTALL.md)

Quick start

from vibo.core import Graph
from vibo.crypto import Crypto, SecurityLevel
from vibo.web import WebFile
from vibo.navigator import ViBoNavigator

# Load memory (or create)
graph = WebFile("memory.web").read() if Path("memory.web").exists() else Graph()
crypto = Crypto(agent_key="my-agent-key", user_password="my-password")

# Save a fact
graph.add_node("Anna", "Client, loves coffee without sugar", tags=["person"])

# Save a secret (never reaches the LLM)
graph.add_node("api-key", crypto.seal(SecurityLevel.L3_SECRET, "sk-..."), level="L3")

# Ask memory
nav = ViBoNavigator(graph, crypto)
context = nav.compose("what about Anna")

# Save
WebFile("memory.web").write(graph, crypto=crypto)

Measured results

Typical savings: 50-150× fewer tokens (up to 2,000× on large memories). Measured, not estimated.

🌐 Product 2: Web Search Savings

Web search results are huge (5-15K tokens per article). Dumping them all into the LLM context is expensive. ViBo compresses them first.

Measured: 96.2% fewer tokens (12,975 → 489 per article).

from vibo_web import compress_article, WebCache

# Compress search results before the LLM sees them
for article in search_results:
    compressed, stats = compress_article(article["text"], query)
    article["text"] = compressed          # only the essence
    print(f"saved {stats['saved_pct']}%")

# Cache — repeated questions cost 0 tokens
cache = WebCache("web_cache.json")
if not cache.get(query):
    results = search(query)
    cache.put(query, results)

🔐 L3 Secrets Vault — the LLM never sees your secrets

Every agent memory system sends context to the LLM. Not us.

L1 — Public:      general facts, always available
L2 — Private:     encrypted at rest, agent-only
L3 — Secrets:     passwords, API keys, medical data —
                  agent knows a secret EXISTS but never receives it.
                  The LLM physically cannot leak what it never saw.

No other agent memory does this — Mem0, Cognee, LangChain Memory all put secrets into the context window.

Secrets aren't just passwords. Business strategy, trading signals, unpublished research, finances, medical data, legal secrets, personal life. Everyone has secrets. Let your agent know they exist — never let it see them.

When does ViBo save you money?

Honest answer: savings come from memory work, not code work.

The bigger the memory, the bigger the savings. ViBo is about memory work: chatting with clients, researching, consulting, planning — anything where the agent needs to recall what it knows.

The math: it pays for itself

Assumptions: 10K facts in memory, 6,000 requests/month (200/day), the agent reads all memory without ViBo. Prices per 1M input tokens.

Honest note (measured, not marketing)

Savings depend on memory size:

In the first days the memory is small, so savings grow over time as facts accumulate.

How the savings work

Every request reads only the relevant facts instead of the whole memory:

Without ViBo: 10,000 facts → ~155,000 tokens → $0.022 (DeepSeek)
With ViBo:    ~2,000 tokens         → $0.0003
                                    → 50-150× fewer tokens

CLI

vibo --file memory.web seed               # demo memory
vibo --file memory.web find "query"       # semantic search
vibo --file memory.web dream              # nightly self-analysis (TTL, dedup)
vibo --file memory.web stats              # statistics
vibo --file memory.web usage              # REAL savings: tokens & money saved

☁️ ViBo Cloud API — memory for YOUR SaaS

Give every user of your product persistent, encrypted memory — one API call. No infrastructure, no tokens burned, 97.5% savings.

# Save a fact for a user
curl -X POST https://wwwvibo.com/memory/add \
  -H "Content-Type: application/json" \
  -d '{"key": "VIBO-...", "label": "user-pref", "content": "Anna prefers email"}'

# Search (only relevant facts → 97.5% fewer tokens)
curl -X POST https://wwwvibo.com/memory/search \
  -H "Content-Type: application/json" \
  -d '{"key": "VIBO-...", "query": "how does Anna want to be contacted?"}'

# Create sub-keys for YOUR users (isolated, encrypted memory each)
curl -X POST https://wwwvibo.com/subkey \
  -H "Content-Type: application/json" \
  -d '{"master_key": "VIBO-...", "user_id": "user-42"}'

• Per-user memory: one master key → up to 100 user sub-keys (Business)
• Encryption L1/L2/L3: secrets never reach the LLM
• Token savings: 97.5% fewer tokens per request, web articles 96-99%
• Zero infrastructure: we host, integrate in 10 minutes (OpenAPI)
• Plans: Starter $5 · Business $10 · Enterprise $25 per month
• Free trial: 2 days, 100 facts — https://wwwvibo.com

OpenAPI spec: integrations/vibo_openapi_dify.json

Roadmap

• Core memory engine (L1/L2/L3 encryption, semantic search)
• .web portable format
• CLI + Python API
• LangChain adapter
• Trial system (2 days, built-in key)
• MCP server (Model Context Protocol)
• Desktop GUI
• Team sharing (multi-user memory)
• Export to JSON/Markdown

License

ViBo is a commercial product. Get a license key: wwwvibo.com

One key = one machine. The core is distributed as a compiled module.