I’m asking because during training or when a system is being sold, you always hear “you can see the customer’s full history here”, but in practice it often seems like a different story.

I’ve had customers call angry because they contacted WhatsApp, then sent an email, and then ended up with another agent. And I’m left trying to piece together what actually happened while the customer is already pissed off.

In your campaigns/companies, does the system really show everything in one place? Or do you still end up opening 5 tabs, searching through spreadsheets, checking another system, or asking another department just to understand what happened?

Sometimes it feels like no matter how expensive the system is, when a case gets complicated, someone still has to do part of the work manually.

What things do you still have to do manually when the system doesn’t give you the full picture?

When working with multi-agent LLM systems, the hard part usually isn't getting a response—it's knowing what actually happened under the hood: which model handled what, what was sent over the network, how much it cost, and whether sensitive data was masked before leaving your machine.

To solve this, I added a visual diagram engine to **Mova Context** in this latest release, allowing you to generate a complete architecture map with a single command: `mova run <project> --diagram`.

Here is a real example output generated from a customer data compliance project running hybrid agents (**Local Ollama + Cloud Gemini**):

context diagram

* **Visual Diagram Engine:** Generates real-time architecture and execution maps using OpenType vector font rendering with WCAG AA contrast standards (clean export to PNG and PDF).

* **Cross-Channel Tracing:** Added execution tracing across CLI, Chat, MCP, and HTTP API with an explicit `[THIS RUN]` indicator.

* **Hybrid Execution Breakdown:** Visualizes local agents (`llama3.2:3b` via Ollama) running alongside cloud agents (`gemini-3-flash-preview`) in the same execution group.

* **PII & Privacy Tracking:** Identifies per-agent status for PII Masking and explicitly tracks how many tokens were pseudonymized before leaving your local network.

* **Cost & Token Transparency:** Explicitly flags local execution as `$0.00 (local — no cost)`, while displaying estimated USD costs for cloud agents calculated *after* context reduction.

* **Token Reduction Pipeline:** Breaks down token overhead by source (prompts, skills, focus files, engine overhead) and displays the total percentage saved.

* **Bilingual Docs:** Fully updated documentation (`README.md` and `COMMANDS.md`) in both English and neutral Spanish.

The project is **100% open source** written in Go.

* **GitHub Repo:** https://github.com/m1guel1982/mova-context

If you find it useful for structuring, auditing, or optimizing token budgets in your agentic workflows, feel free to check it out, star the repo, or drop feedback in the comments!

For a while now, I've been measuring how many tokens we waste resending noisy logs, repeated code comments, or bloated structures that the model doesn't actually need to solve a task.

In this latest release, I built and benchmarked a simple test project (ejemplo-token-firewall) containing a code file and a 53-line log file (48 of which were nearly identical):

• Without Token Firewall: 2,737 tokens sent per run.
• With Token Firewall: 1,764 tokens sent per run.

That’s a 35.6% direct reduction without modifying the codebase or altering the context's underlying meaning.

On top of that, I added the Cache Layout Guard: it reorganizes the prompt to maintain a stable prefix (agents + skills + prompt = 1,167 tokens in this example), making it ready for providers like Anthropic, OpenAI, or Gemini to trigger their native prompt caching depending on the available window.

How does this differ from other tools?

It's not that other tools lack cost control. The difference is that Mova Context flattens this entire process into a single deterministic, auditable, and automated pipeline right before every API call:

• Zero Black Boxes: Uses a deterministic algorithm to strip out noise (runs in microseconds, without using another LLM that consumes tokens just to summarize).
• Real Auditability: Detailed reports show exactly how many tokens and dollars you saved per file.
• Multi-channel: Works identically across the terminal, chat interfaces, scheduled jobs, multi-agent orchestrations, and via HTTP/MCP.
• Circuit Breaker: If a run exceeds your pre-configured budget/limit, it aborts before making the outbound HTTP request to the LLM provider.

What’s new in this release?

• Job Engine: Run scheduled background tasks via cron using a background daemon (mova jobs start).
• Multi-Agent Orchestration: Coordinate grouped agents directly through a config.json.
• New TUI (mova ui): A full terminal interface built with Bubble Tea to manage projects, jobs, logs, and chats.
• Logging & Rotation Systems: Configurable log levels for full end-to-end traceability.
• Improved Installers: Direct setup with pre-configured consoles for Windows, macOS, and Linux (including full support for UNC paths, WSL, and Docker).
• Documentation & Walkthroughs: Step-by-step guides backed by real execution data inside /examples.

Mova doesn't promise to cut your LLM bill in half across every single scenario (if your code is already pristine or your context is genuinely massive, the impact percentage will be lower). It is an architectural hygiene layer for your context, engineered to prevent unnecessary spending.

The project is fully open source. If you test it out on your projects, any feedback, edge-case report, or issue on the repository would be hugely appreciated!

You can check out the source code, CLI, and setup guides here:

👉https://github.com/m1guel1982/mova-context

Includes practical examples with mova budget, pricing configurations in prices.json, and Chat/MCP/HTTP integrations.

Any feedback or issue is more than welcome!