OpenClaw 4.7 Release Notes: Memory Wiki, Webhooks, and Session Restore

By Beau Johnsonยทยท9 min read

Quick answer

OpenClaw 4.7 adds Memory Wiki, which gives agent memory structure (claims carry evidence, contradictions are grouped, stale facts are flagged), webhooks that let outside tools trigger agent work in real time, and session branch and restore so long sessions can be recovered after compaction.

OpenClaw 4.7 dropped in the middle of the night, and this one matters. A lot.

Most release notes sound bigger than they are. This one does not. OpenClaw 4.7 changes how your AI agent remembers, how it connects to the rest of your stack, and how it recovers when things go sideways.

If you are building with AI agents right now, this is the kind of update you pay attention to because it pushes OpenClaw further away from toy automation and closer to real infrastructure.

Why OpenClaw 4.7 feels like a real jump

The headline is simple. OpenClaw 4.7 makes agents more reliable, more connected, and a lot better at handling long running work.

That sounds abstract, so let me make it concrete. Before this update, agents could remember things, but memory was still messy. They could do work, but they still felt a little disconnected from outside systems. They could run long sessions, but recovering earlier context was painful once compaction happened.

OpenClaw 4.7 attacks all three.

  • Memory Wiki makes agent memory structured instead of flat.
  • Webhooks let outside tools trigger real work in real time.
  • Session branch and restore makes long sessions recoverable instead of fragile.

That is a big shift. It means your agent is not just doing tasks. It is starting to behave more like a system you can actually build a business on.

Memory Wiki is the feature that matters most

If I had to pick one feature from OpenClaw 4.7 that matters six months from now, it is Memory Wiki.

Most agent memory today is basically a pile of notes. Useful, but messy. You can store information, but the agent has a hard time knowing what is still true, what conflicts with something newer, and what is stale enough to stop trusting.

Memory Wiki changes that.

Instead of treating memory like random text, OpenClaw now gives it structure. Claims can carry evidence. Contradictions can be clustered. Older information can be surfaced as stale. Search can favor fresher information instead of blindly treating everything as equal.

That might sound like a technical detail. It is not. It changes the quality of the agent's decisions.

Think about a real use case. Maybe your agent helps with customer support, pricing questions, content operations, or sales follow up. If it remembered an old pricing plan and treated it like current truth, that is a problem. If it stored two conflicting facts and never surfaced the tension, that is a problem too.

Memory Wiki is a move from storage to knowledge management. That is the upgrade.

Why structured memory matters for builders

Here is the practical takeaway. Better memory quality means better downstream execution.

  • Your content agents can stop pulling stale messaging.
  • Your support agents can detect outdated facts faster.
  • Your operations agents can treat newer instructions as higher trust.
  • Your main assistant can reason across contradictions instead of quietly carrying both around.

That is the difference between an agent that merely remembers and an agent that starts to understand what should still count as truth.

openclaw infer makes model work simpler

Another sleeper feature in this release is openclaw infer.

This is a new CLI command that gives you a provider-backed inference hub for model tasks, media generation, web tasks, and embeddings right from the command line.

Why does that matter? Because a lot of builders still waste time wiring up individual provider APIs just to run one model task, one image task, or one retrieval flow.

That work is annoying. It is repetitive. It slows everything down.

With openclaw infer, a chunk of that integration friction goes away. Instead of building a custom wrapper for every provider, you get a cleaner command line entry point inside the platform you are already using.

That is not flashy, but it is exactly the kind of feature that saves hours for serious builders.

Webhooks turn OpenClaw into a live part of your stack

This is the part a lot of people have been waiting for.

OpenClaw 4.7 adds webhook ingress so outside systems can trigger TaskFlows through shared-secret routes. In plain English, your external tools can now wake up your agent and make it do real work the moment something happens.

That means things like:

  • Stripe triggers an onboarding workflow after a payment lands.
  • GitHub triggers a review flow when a pull request opens.
  • Your CRM triggers a follow up sequence when a deal closes.
  • Your backend triggers a processing task when a new user signs up.

Before this, a lot of agent workflows still felt manual. Powerful, yes. But manual. Someone had to push the button.

Webhooks change the category. Your agent becomes event driven. It stops acting like a disconnected assistant and starts acting like an operator wired into the rest of your business.

Why this matters more than the feature list suggests

The real story is not just that webhooks exist. It is what they unlock.

Once your agent can respond to business events automatically, you stop thinking of it as a chat interface and start thinking of it as a workflow engine with judgment.

That is where the leverage is.

Session branch and restore fixes one of the worst long session problems

If you have done serious work with agents, you know this pain.

Long sessions get compacted. That is necessary. Context windows are finite. But once compaction happens, it often feels like the original detail is gone forever.

OpenClaw 4.7 adds compaction checkpoints and lets you branch or restore from pre-compaction states in the Sessions UI.

That is huge.

It means old context is not just summarized and buried. It is recoverable. You can inspect it, branch from it, and continue from it. If something weird happened in a long build session, you now have a way back.

Honestly, this feels like version control for working memory. And that is exactly what long running agent work needs.

Memory Dreaming and media fallback improve reliability

Two more features deserve attention because they push the system toward stability.

First, Memory Dreaming got better. OpenClaw can now ingest redacted session transcripts into the dreaming corpus with per day notes and cursor checkpointing. That means better long term memory synthesis happening in the background.

Second, media generation auto fallback is now built in across image, music, and video providers. If one provider fails, OpenClaw can switch to another and remap size or aspect ratio to the closest supported option.

This is the kind of feature people ignore until a workflow breaks at 2 AM.

For anyone running content pipelines, this matters a lot. Reliability beats cleverness every time.

New model support expands the stack

OpenClaw 4.7 also adds support for more models and providers, including Gemma 4, Arcee AI, and Ollama vision support for local image aware workflows.

The point here is flexibility. Better provider coverage gives builders more room to route for cost, privacy, and quality depending on the job.

And that matters because the future is not one sacred model. The future is routing the right work to the right model with the right economics.

Who should care about OpenClaw 4.7

If you are just casually playing with AI tools, this release might feel technical.

If you are actually building with agents, it is the opposite. It is practical.

You should care about OpenClaw 4.7 if you are:

  • Running long lived agent sessions and worried about context loss.
  • Using agents for memory heavy workflows.
  • Trying to connect agents to business events in real time.
  • Building content pipelines that need provider reliability.
  • Operating a multi tool stack where better model routing matters.

This release is not about one flashy demo. It is about making the whole operating layer stronger.

FAQ

What is the biggest feature in OpenClaw 4.7?

Memory Wiki is the biggest feature because it upgrades agent memory from loose note storage into a structured system with evidence, contradiction detection, and freshness-aware search.

Why do webhooks matter in OpenClaw 4.7?

Webhooks matter because they let outside tools trigger agent workflows automatically, which turns OpenClaw into a live part of your business stack instead of a separate tool you have to manually prompt.

What does session branch and restore do?

It lets you recover and branch from pre-compaction session states, which means you can revisit earlier context instead of losing detail after long sessions get summarized.

Final take

OpenClaw 4.7 is a serious release. Not because it added a bunch of features, but because the features all push in the same direction.

Better memory. Better recoverability. Better connectivity. Better reliability.

That is how a platform goes from interesting to indispensable.

If you are already building with OpenClaw, I would not treat this as optional. And if you are trying to understand how to use features like Memory Wiki, webhooks, and session restore in real builds, that is exactly the kind of work we break down inside Shipping Skool.

Join Shipping Skool here and learn how to build real AI agent systems that actually ship.

Chapters

  1. 0:00OpenClaw 4.7 dropped at 2am and everything changed
  2. 1:00Memory Wiki: from sticky notes to real knowledge management
  3. 3:00openclaw infer: one-liner inference from the CLI
  4. 4:30Webhooks: your agent is now wired into your entire stack
  5. 6:30Session branch and restore: version control for agent memory
  6. 8:00Memory Dreaming upgrade: smarter overnight learning
  7. 9:30Media generation auto-fallback across providers
  8. 10:30New model support: Gemma 4, Arcee AI, Ollama vision
  9. 11:30Pluggable compaction and systemPromptOverride
  10. 12:30Why 4.7 is not optional if you're building with OpenClaw

Transcript

Read the full transcript

0:00Hey, guess what? An open-claw version just dropped, and here's everything you need to know. This is kind of a late release. It just dropped about an hour ago, and open-claw 4.7 does bring in a lot of new features and a lot of new bug fixes. So, before you go ahead and update your open-claw, here is everything you need to know to make sure that it's even worth upgrading to because if you have a working pipeline and an AI agent that works perfectly, you may want to hold off upgrading until you see a feature that is going to serve your system. So, what dropped just a few hours ago is not just a patch release, and it's not just a bug fix with a fancy version number slapped onto it. This is actually a fundamental upgrade to how your AI agent thinks, how it remembers, and how it connects to everything else

0:46inside your tech stack. And if you're building anything with AI right now, you need to understand what the difference is between 4.5 and this 4.7 update. So, the biggest feature in this release, I have to say, and I mean that is one that's going to matter the most in like 6 months from now, is that memory fix. It's called memory wiki. So, before this, your agent stored memory in flat files. So, if you think of it like a pile of sticky notes scattered across a desk, the information is there somewhere, but there's no organization, no way to tell if two notes are contradicting each other, no way to know if something you wrote down 6 weeks ago is still accurate or completely outdated. Memory wiki throws that whole model out. It is a full wiki system

1:31built specifically for agent memory. If you are working with open-claw, you know the number one problem with open-claw is memory. I mean, I back up my memory in four different ways, and it took me over 60 days to perfect this. So, memory seems to be a persistent issue across the whole ecosystem. It seems like they fixed that in this latest update. Like, it has a structured claim and evidence field, which means every piece of information has real context attached to it. It has contradiction clustering, which means the system finds when things conflict and basically surfaces that to you. It has a staleness dashboard, so when you can see what is old and what is fresh, and it has freshness-weighted search. Say that three times. Meaning, when you look at something and it looks

2:16something up, newer information gets prioritized over stale old information automatically. Real quick, before we keep going, if you're watching this and you want to actually build with some of these tools, not just watch videos about them, then you're going to want to check out our community down below, Shipping School. We have a full Claude Code course, a full Open-Claw course, and four live bootcamps every single week, where we actually help you get set up from scratch. Like, actually set this thing up, not just watch a tutorial and figure it out by yourself. And we also provide one-on-one coaching, so you could book a call with me, we could share screens, and I can help you get Claude Code or Open-Claw running on your machine. That's it, no fluff. I built this community because watching

3:01YouTube's only gets you so far. We launched it just 3 days ago, and we have over 55 members. You need people around you who are actually building, people who hold you accountable, and coaches who can help you when you get stuck. I'll put the link in the description down below. Get in now before the price goes up. So, if you think about what this actually means for your builds, you're running an agent that handles your customer support, your content pipeline, and your sales follow-up. Today, it remembers things in text files. Tomorrow, it knows that fact A contradicts fact B. It knows the pricing you wrote down 3 months ago might be outdated, and it knows what to trust and what to question. That is not just memory, that is knowledge management, and that is a completely different capability. The second major update I

3:47want to talk about is an open-claw infer, brand new CLI command, first class in the tool. You open up your terminal, you type in open-claw infer, and you get a provider back-end inference hub. So, model tasks, media tasks, web tasks, embeddings, all of it from the command line. So, for builders, this changes your workflow completely. You used to write down API integration code, handle authentication, manage provider-specific request formats, build your own retry and fallback logic, all of that just to run a model to generate an image. Now, you just type one command and that's it. A task that used to be a multi-day integration project is now one-liner. That is not a small quality-of-life improvement, that is a fundamental shift in how fast you can

4:33move and build now. Webhooks landed in this release as well, and I know a lot of people have been waiting for this one. The webhook ingress plugin lets external information drive your open-claw task flows through per-route shared secret endpoints. So, let me say that in plain English cuz that's a lot right there. Anything that could fire a webhook can now talk to your agent and trigger real work. That's pretty cool. So, Zapier files a webhook, and your agent responds. Stripe files a webhook when a payment lands, your agent handles the follow-up. GitHub files a webhook when a pull request opens, your agent reviews the diff. Your back-end files a webhook with new user data, your agent processes it. Your CRM files a webhook when your deal closes, your agent drafts the onboarding message. This is a huge

5:19change in how your workflow is going to work, and I love this cuz it's more of those little upgrades that allow you to have this agent run a little more autonomously, and that integration is going to help huge. For me and my business, I think that Stripe webhook is going to be really helpful, so I don't have to manually copy-paste and keep my agent up to date on tracking revenue. So, before this, like for example, your agent was its own island, very powerful, but disconnected from the rest of what you were building, especially if you're doing like a CRM or customer service, or like I said, managing your Stripe for payments, you had to push the work into it manually. Now, it's already wired in. Now, it's live, and it's a participant in your entire workflow, responding to events as they happen, not just when you

6:04remember to check in. This is a fundamentally different category of tool. Session branch and restore, this is one that might sound more developer-focused, but just stay with me because this is actually about never losing your work again. So, when a session gets long enough, Open-Claw compacts it, right? It summarizes old context to save space and keep things running efficiently, and that is fine. That is necessary, right? But until now, once something was compacted, it was basically gone. You could not go back and look what what the agent knew before the summary happened. 4.7 changes that. Open-Claw now creates compaction checkpoints from the session's UUID. You can now branch and restore from any pre-compaction state. You can inspect it, recover it, and continue from it. This is the version control for your

6:49agent working memory. How many times have you been in a deep long build session, something weird happens, context gets lost, and hours of work evaporates. I've been there. That does not happen anymore with this newest update. You have checkpoints. You have recovery. That is production-grade reliability. Memory dreaming just got an upgrade, too. This came out in the last update, where you have deep sleep and REM cycles, but this quick background for anyone new to this on that update is dreaming is the process where your agent takes old session transcripts and process them into background to build better long-term memories. It is a similar to how humans dream and consolidate memories during sleep, even though I can never remember my dreams, but that doesn't matter, right? Your agent does something like that. So, it's synthesizing the past sessions into

7:35structured knowledge. The 4.7 upgrade means dreaming now ingest redacted session transcripts into dreaming corpus with per-day session corpus notes and cursor checkpointing. The dreams are smarter, as well. The memories that come out of the dreaming process are actually more accurate and more useful, so your agent is getting a sharper overnight automatically without you doing anything. And that is the kind of compounding advantage that adds up fast. Media generation auto fallback, this is the next one that's huge. This is a quiet reliability feature that is going to save a ton of people a lot of headaches. You know what happens when an image generating provider goes down in the middle of a workflow? Everything breaks. Your pipeline fails, you wake up to a pile of failed tasks and costs in

8:22API calls. You have to manually switch providers, update configs, retry everything. Nah, nah, nah, no more. 4.7 handles this automatically. Open-Claw now falls back across image, music, and video providers without any intervention from you. If one provider goes down, it just switches. It also remaps size and aspect ratio hints to the closest supported option on the new provider, so you don't have to reconfigure anything. For anyone running a content pipeline through Open-Claw, this is a massive upgrade. Your pipeline keeps running even when a provider has a bad night. New model support landed, too. Gemini 4 from Google is now natively supported. A Cree AI is now bundled provider with Trinity catalog entries and OpenRouter

9:08support. More models means more options, more flexibility to dial in the right cost and quality trade-off for your specific use case. A Llama Vision support is now integrated, as well, which is pretty nice. So, if you're running a Llama locally and your model supports vision, it automatically accepts image attachments. Local, private, and no API calls leaving your machine. Full vision capability. That's sweet. And that is a powerful setup for anyone who wants to keep certain workflows completely off their own hardware. Plugin compaction. This one is for the people who want deep control over the how their agent thinks over time. You can now replace the built-in summarization pipeline with your own provider. Why does this matter? Because compaction is how your agent preserves what it knows across your long sessions.

9:54Better compaction equals a smarter agent over time. If you have a custom approach that fits your domain better, you can plug it in now. That is real configurability. System prompt override. It's clean and simple. You can now run controlled prompt experiments without touching your main config. You could test a different persona, try a different instruction set, run AB comparison on agent behavior. None of it touches production until you decide to promote it. Safe experimentation baked right into the platform. >> If you're struggling to keep up with content, what I'm about to save you about 40 days worth of work. I built something called content machine. [music] It's 10 AI agents that run on the open claw orchestration and they handle everything. Scripts, [music]

10:39thumbnails, X posts, blogs, outreach, clips, newsletters, all of it. So, I went from 1,000 subscribers to 4,000 subscribers on YouTube in 7 days using this exact system. Every single morning I wake [music] up and the content's already done. I spend maybe 15, 20 minutes reviewing and approving them and I move on with my day. It works for [music] any niche, fitness, finance, real estate, marketing, whatever you're building and it is 100% completely customizable to your [music] use case. So, you get the mission control dashboard, all of the cron jobs, everything I've built over the last 40 days helping me gain more and more people to subscribe and join the community. So, you plug in your own

11:24thing and it molds it to you. It learns how you talk and it writes so it doesn't sound like AI slop. $97 one time. It's not a subscription. I'll put the link down below and you'll thank me later. Claude CLI is back. Praise hallelujah be to God. Restored as the preferred local Anthropic path to onboarding. For anyone who missed it, welcome back. Now, I'm not saying you can use your OAuth subscription again. That would be a party, but the CLI is back. And I'll tell you how you can So, on the fixes side, they shipped several good ones. TTS audio replies actually show up in web chat. Mobile exact approval UI is fixed. iOS connection errors now surface with actionable messages instead of cryptic failures that leave you guessing. History apply alignment is

12:10cleaned up across multiple PRs. Plugin media capability fallback is working properly now. Back to the CLI for Claude. It was removed from the onboarding. So, before you didn't get to be able to connect your Claude account through the CLI. Now, you can when you go through the open claw config onboarding. And that's pretty cool because people were freaking out with this last upgrade. So, fixes matter just as much as features, which I wanted to cover that. You know, a reliable system beats a feature-rich broken one every single time. Some of these upgrades have huge features that are, you know, put into open claw and many times in our group where people have upgraded because of a certain feature, but it came with tons of bugs, which is why I said at the beginning of this video, only upgrade your open claw if there's a feature in

12:55here that's worth upgrading to you. It's been 8 weeks for me to get my pipeline working and with this 4.5 update I did just a couple days ago, I think it was yesterday, this morning I spent 5 hours reconfiguring my whole system because something in 4.5 broke the thumbnail generation agent, the script agent, and it was a mess. So, I'm just prefacing to say that only if you see a feature in here and you can review it for yourself, I'll put the link down below. That is when it's worth upgrading. If your system is dialed in and there's nothing in the 4.7 upgrade that's worth you updating to, wait for the next one. It's probably going to drop in a day or two. So, the main takeaway is like open claw is shipping fast and every release is closing the gap between AI experiment

13:41and actual production infrastructure. 4.7 is one of those bigger jumps. That memory wiki means your agent can build and maintain real knowledge, not just store text. So, if you are having a hard time with memory, like let's just say your agent's forgetting stuff and you have lossless claw installed. You have QMD memory installed. You have super memory in the cloud. You have neon or superbase or convex for your backend database and you have GitHub going on and you have the heartbeat being stored with memory session every 2 hours and you're still having trouble, then that would probably prompt you to up That's what I'm saying. Also, webhooks is a pretty good one, too. I like that, especially if you're dealing a lot with stripe payments or you're building a CRM. Just the fact that, you know, your

14:26agent can get that information through a webhook. I love that. Like webhooks being wired into the whole stack, that's a huge. Session restore means you'll never lose critical context. Media fallback means your content pipelines do not break when a provider has a bad day. Pluggable compaction means you control the intelligence layer. This platform is becoming something serious. I know it was a month ago, but this is getting insane. If you're not building with it yet, like come on. This is the release to pay attention to. If you're already on it, I applaud you, but upgrading to 4.7 is I don't think an optional one in my playbook. There's a lot of good things in here. Like I said, if there's nothing in here that's going to be relevant to you and you have that figured out, then don't upgrade. And for everyone in the community, we have 212 people in a community I started 23 days

15:12ago. We focus on open claw, Claude code, AI agents, building with AI. We have people that haven't even installed open claw yet and we have people that are actually making money with open claw. So, for the people inside of shipping school, we are covering the biggest features on the next live call. We do nine live calls a week, by the way. And memory wiki setup, webhook integrations, session restore workflow, the real practical stuff that we'll go over in these calls. So, if you're not in the shipping school community yet, it is where I teach everything I know building with AI. Basically, the things that I'm building are the content pipeline and managing my businesses. Actual builds, real tools, a community of people shipping things. I'll put the link to it down below. And if you haven't subscribed to the channel already, I do release two to four to six videos per

15:59day depending on if family's visiting or not or depending on the news for the day, but you should subscribe if you like things that have to do with AI and open claw. Otherwise, we'll see you in the next video. Have a blessed night.

Ready to start building with AI?

Join the Shipping Skool community free. Paid members get live bootcamp calls every week and weekly-updated courses.

Join Shipping Skool

Keep reading