Most AI in SaaS is a black box. You ask it a question. It answers. You don’t know what it read, what it changed, or why it decided to do what it did. When it makes a mistake, it makes the same mistake next week. Nobody knows what it touched. Nobody knows what it didn’t.

This is why most AI in SaaS doesn’t ship. The risk is unbounded. The company can’t see what the AI did, can’t audit it, and can’t prevent it from doing it again. So the AI gets gated behind a “summary only” wall — it can read, but it can’t write. It’s a chatbot. It’s not an agent.

MoveRight’s AI is different. It has a page tree that maps every page and feature the AI can see. It has a diff view that shows exactly what the AI changed, line by line. It has a changelog memory — the AI reads its own changelog to avoid repeating past mistakes. Here’s how it works.

The Page Tree: What the AI Can See

The Self-Improving AI (SIA) dashboard ships with a page tree navigation panel (Changelog_2606.md !1859, expanded in !2126). The tree maps every page and feature in MoveRight that the AI is allowed to see and act on.

This is the AI’s map. When it analyzes a job, it knows which pages are relevant — the job activity page, the calculator, the documents tab, the crew navigator. It doesn’t wander. It doesn’t hallucinate pages that don’t exist. The tree constrains what it can look at, and therefore what it can act on.

The tree is built from the path hierarchy — the same routing structure the frontend uses. When a new page ships, it appears in the tree. When a page is removed, it disappears. The AI’s map is always current because it’s derived from the live application, not a static config file.

The Diff View: What the AI Changed

The SIA dashboard includes a unified diff view (!2126). When the AI makes a change — updates a job summary, applies a suggested fix, runs a calculator — the diff view shows exactly what changed, line by line.

This is the audit trail. A human reviewer can open the diff, see what the AI added, what it removed, and what it left alone. The diff is precomputed — the dashboard doesn’t recompute it on every render cycle (!2126), so the review is fast even on large changes.

If the AI changed something it shouldn’t have, the diff shows it. If the AI didn’t change something it should have, the diff shows that too. There’s no “the AI did something and we’re not sure what.” The diff is the record.

The Changelog Memory: Why the AI Doesn’t Repeat Mistakes

Here’s the part that makes the AI self-improving. The SIA dashboard has a changelog memory (!2126). The AI reads its own changelog — the same changelog you can read in /releases/ — and uses it as context for future decisions.

When the AI makes a mistake, the fix lands in the changelog. The next time the AI encounters a similar situation, it reads the changelog, sees the mistake, and avoids it. This is not a human reading a postmortem. This is the AI reading its own history and adjusting.

Here’s a concrete example. We let Bee — MoveRight’s AI agent — write a customer’s inventory. The AI filled in inventory items based on the Yembo walkthrough data. The results were wrong. Items were duplicated. Rooms were misassigned. We turned the feature off. The mistake, the fix, and the reason are all in the changelog. The AI now reads that changelog before touching inventory, and it knows: this was tried, it failed, here’s why, don’t do it again.

That’s the Bee AI inventory mistake — and the AI remembers it.

The Suggest/Assist/Auto Framework

MoveRight’s AI operates on three levels of autonomy:

Suggest — the AI proposes a change. A human reviews the diff and approves or rejects. The AI doesn’t touch anything.
Assist — the AI makes the change, but a human must confirm before it’s saved. The diff is visible. The human clicks “accept.”
Auto — the AI makes the change and it’s saved. The diff is still visible in the SIA dashboard. A human can review after the fact and revert if needed.

The two-phase heartbeat rollout (Changelog_2606.md !1859, !2126) is the foundation. Phase 1 decides whether action is needed. Phase 2 generates the summary only when required, sharing a cacheable message prefix to reduce AI costs. The AI doesn’t run full analysis on every job every cycle. It runs a lightweight decision pass first, and only spends tokens when the decision pass says “this job needs attention.”

The Ask-Bee Scheduling Fix

Here’s another concrete example of the AI learning from its own changes. In Changelog_2607.md !2153, Ask-Bee — the AI that schedules follow-up calls — was scheduling next-day calls outside business hours. A customer who needed a callback at 9 AM was getting a call scheduled for 6 AM, when nobody was in the office to take the reply.

The fix: Ask-Bee now respects business hours when scheduling next-day calls. The business-hours constraint is in the changelog. The AI reads it. The next time Ask-Bee schedules a call, it knows the window.

This is the same pattern as the inventory mistake. The AI did something wrong. The fix shipped. The changelog recorded it. The AI’s next cycle reads the changelog and adjusts.

Anthropic Prompt Caching

In Changelog_2607.md !2162, we fixed Anthropic prompt caching via the anthropic-beta header. This isn’t a user-facing feature, but it matters for the self-improving story. Prompt caching means the AI can read its own changelog — a long document — without re-paying for the tokens on every cycle. The cacheable message prefix from the two-phase heartbeat (!2126) works the same way.

The AI reads more context. The cost doesn’t scale linearly. That’s what makes the changelog memory economically viable. Without caching, reading the full changelog on every job analysis would be prohibitively expensive. With caching, the changelog is read once, cached, and reused across every job in the cycle.

When the AI Calls a Function That Doesn’t Exist

Here’s the most honest engineering moment in this article. In Changelog_2608.md !2260, we fixed a bug where AI execution crashed when the model requested an unavailable function. The AI would try to call update_inventory (which doesn’t exist as an AI function), and the entire execution would crash. No summary. No diff. No record. Just a dead thread.

The fix: the AI no longer crashes. It records an explicit missing-function error. The execution continues. The SIA dashboard shows the error. A human can see that the AI tried to call a function that doesn’t exist — which tells you something about what the AI was trying to do, even if it couldn’t do it.

In Changelog_2609.md !2309, we went further. The AI no longer stops when it calls a non-existent function. And Yembo inventory item names are now visible to the AI — so when the AI summarizes a job’s inventory, it sees the actual item names (“3-seat sofa,” “queen bed frame”), not internal IDs. The summaries are complete. The AI can reason about inventory because it can read it.

	Before !2260	After !2260 / !2309
AI calls a non-existent function	Execution crashes, no record	Error logged, execution continues
Yembo inventory item names	Not visible to AI	Visible to AI
Job inventory summaries	Generic, missing item names	Complete, with item names

What the SIA Dashboard Looks Like in Practice

A dispatcher opens the SIA dashboard. The page tree shows the job activity page, the calculator, and the documents tab — the pages the AI analyzed for this job. The diff view shows that the AI updated the admin summary with a cost breakdown and a recommended next step. The changelog memory panel shows the last five changelog entries the AI read before making its suggestion.

The dispatcher reviews the diff. The summary is accurate. The cost breakdown matches the calculator. The recommended next step — “call customer to confirm packing services” — is reasonable. The dispatcher clicks “accept.” The summary saves. The job activity page updates.

If the summary was wrong, the dispatcher clicks “reject.” The diff is recorded. The AI’s changelog memory includes the rejection. The next time the AI analyzes a similar job, it reads the rejection and adjusts.

This is the loop. The AI acts. The human reviews. The changelog records. The AI reads the changelog. The AI improves.

MoveRight is the moving company CRM that gives its AI a page tree, a diff view, and a changelog memory — so the AI can see what it changed, learn from what it broke, and never make the same mistake twice.

See how it works

References:

The Self-Improving AI Dashboard: How MoveRight's AI Learns from Its Own Changes