---
title: "Corrections That Stick"
description: "Self-modifying agents, and how to verify a correction survived the night."
order: 37
duration: "10 min"
chapter: "09-running-agents-in-production"
type: lesson
---

## Interact, correct, verify

Start a chat session with your agent:

```bash
umwelten chat bookkeeping-agent
```

Ask a real question. Make a correction. End the session. Start a new session. Verify the correction persisted.

Cornwall Market: Sarah starts a chat with the bookkeeping agent and asks about a $600 invoice from Chen's Produce.

The agent categorizes it correctly — account 5100. Sarah says, "Actually, any Chen's Produce items over $500 should be flagged for manager review. We had a case quantity error last quarter and I want to catch those early."

The agent acknowledges the correction and updates its categorization skill — adding a new exception rule. Sarah ends the session.

She starts a new session the next day. "I have a $720 invoice from Chen's Produce." The agent categorizes it to 5100 *and* flags it for manager review, citing the rule Sarah added yesterday. The correction stuck.

<div class="exercise">
  <div class="callout-label">Try This</div>
  <p>Run <code>umwelten chat your-agent</code>. Ask a real question from your domain. Then make a correction — tell the agent something it should do differently next time. End the session. Start a new one. Ask a question that should trigger the correction. Did it persist?</p>
  <p>If you enabled <code>self-modify</code> in your habitat config, the agent updated its own skill files. Check the skill — you will see the correction recorded. This is the feedback loop in action.</p>
</div>

## One agent, many windows

The same habitat, with the same tools and the same memory, is accessible from any interface:

| Interface | How It Works | Best For |
|-----------|-------------|----------|
| **CLI** | `umwelten chat bookkeeping-agent` | Interactive development, debugging, corrections |
| **Telegram** | Message the bot directly | Mobile access, quick checks, approvals |
| **Discord** | Channel or DM | Team collaboration, shared visibility |
| **Web dashboard** | Open in browser | History review, team access, management |

The interface is a surface. The agent underneath is the same. A correction you make on Telegram is reflected when you open the CLI. A decision logged in the web dashboard is available in Discord. One agent, many windows.

Every conversation is a `transcript.jsonl` file — searchable, replayable, exportable. When the agent picks up a conversation tomorrow, it loads the transcript and has full context. When you want to audit what the agent did last Tuesday, you search the transcripts.

### Multi-provider strategy

Umwelten supports multiple providers through a single `getModel()` interface:

```typescript
import { getModel } from 'umwelten';

const claude = getModel('claude-sonnet-5');
const gemini = getModel('gemini-3.5-pro');
const local  = getModel('ollama:qwen3');

// All return the same interface — swap freely
const response = await claude.generate(prompt, { tools });
```

Same interface, any provider. The eval system uses this to test across providers. The production system uses it to route requests. Same code, different purposes.

## Check your understanding

Answer in your own words — write it down before opening the key. Your tutor grades against the criteria and generates fresh variants on retries.

**Q1.** In a habitat, what makes a correction persist across sessions, and how would you verify tomorrow that a correction you made today actually stuck?

<details>
<summary>Answer key — attempt every question first</summary>

## Answer key

### Q1

**Model answer:** Persistence comes from the correction being written into the habitat's files — the skill or memory files the agent loads at startup — not merely said in a conversation. Verification: start a fresh session tomorrow, pose a case that triggers the rule, and confirm the agent applies it; optionally check the skill file's diff to see the correction recorded.

**Pass criteria:** file/memory write as the persistence mechanism; verification = fresh session + triggering case (and/or inspecting the diff)

</details>


**Next:** [From Eval to Production](/mastering-claude/09-running-agents-in-production/38-eval-to-production/)