Every run makes your agents smarter.

# Intelligence — Mubit

Every run makes your agents smarter.

Mubit watches your agents end-to-end — what they tried, what worked, what broke. An agentic layer reads each run, distills the lesson, and feeds it into the next one. Built on the same execution memory that powers your retrieval.

## In practice: what continuous learning looks like in production

### Support agents that share one understanding across every channel.
Your chat and voice agents work the same customers from different channels. Every interaction — what tone worked, when to escalate, how to recover an account — gets written into the same Mubit memory both agents read from. No knowledge gap when the customer switches.

### Outbound agents that learn in the run, not the next sprint.
SDR tools surface insights to humans who tune templates next sprint. Mubit closes the loop between sends — every reply is captured by the agentic layer, distilled into a lesson scoped to this prospect and this objection, and written to the memory the agent reads from before composing the next outreach.

### Coding agents that don't repeat their failures.
Two failed attempts at the same broken import resolution surface as a flagged antipattern. Mubit captures the fix the third run got right and writes it as a retrievable lesson — the next code-gen run reads it before generating imports.

## Why it matters: inspect what your agent learned

Every captured lesson, decision, and outcome is indexed and queryable. Ask in plain English or query directly — the same execution memory your agent retrieves from is the one your team explores.

- Natural-language → structured query.

- Filter by tool, lesson, verifier, latency.

- Replay any run from any point in time.

## FAQ

**What does Intelligence capture, and how does it turn into a lesson?**
Every run end-to-end — inputs, prompts, recalled lessons, tool calls, verifier outcomes. Once the run completes, an agentic layer reads the trace, distills the outcome into a structured lesson, and writes it to your execution memory. The next agent retrieving against that memory gets the lesson injected automatically.

**Will this slow my agents down?**
No. Runs are emitted asynchronously over a non-blocking pipe — typical overhead is under a millisecond per step and never on your agent's critical path. Lesson distillation happens after the run completes, not in line with it.

**Can I see what my agent learned, and when?**
Yes. Every distilled lesson is a structured record linked to the runs that produced it. Search in plain English, filter by tool or verifier, see which lessons fired in which runs, and compare lesson versions over time.

**Can I see why my agent picked one tool over another?**
Yes. Each decision step records the candidate tools, their scores, the lessons that nudged the ranking, and the final pick. The full causal chain shows up next to the trace — and feeds back into future tool selection.

**What happens when a run fails?**
The trace is preserved with the failure point highlighted, a root-cause summary attached, and — when there's a clear pattern — a lesson captured automatically. Similar past failures are linked, so the next agent has both the receipt and the fix.

**How long are traces and lessons kept?**
Unlimited retention by default. Both traces and the lessons distilled from them are stored in your own region with column-level encryption — compliance-ready out of the box.

**Does Intelligence work with any framework?**
Yes. Wrap your run with the Mubit SDK or send events through the HTTP ingest. LangChain, LangGraph, custom orchestration, plain OpenAI/Anthropic calls — all supported. Lessons feed back into whatever retrieval setup you use.