DEV Community: b-tec

The Runway

b-tec — Fri, 27 Feb 2026 16:11:36 +0000

The Runway

I opened Google the other day. Just a search. Something I've done many thousand times. And for the first time in my life, it felt like getting on a bicycle.

Not broken. Not slow, exactly. Just... small.

That's a weird thing to feel about a tool that basically organized human knowledge for twenty plus years. I didn't go looking for that feeling. It just showed up. Like when you fly somewhere for the first time and then try to imagine driving the same distance. The car isn't worse. You just know something now that you didn't know before.

I've been in technology for over thirty years. I was there when the commercial internet went from a curiosity to the backbone of everything. I watched mobile go from a novelty to the thing that rewired human behavior. I lived through cloud, through SaaS, through every hype cycle and every real shift.

I am not easily impressed. I don't write things like this.

That matters, because I need you to understand that what I'm about to describe is not enthusiasm. It's recognition. The same recognition I felt in 1994 when I realized the internet wasn't going away. The same pit in my stomach. The same quiet thought: everything is about to change and most people don't see it yet.

But before I get there, let me be honest about something.

The Corolla Is a Good Car

ChatGPT is genuinely useful. I'm not here to trash it. When it showed up a few years ago, I used it, and I thought: this is a well-built car. It gets you where you're going. It handles well. Millions of people use it every day and get real value from it. That's not nothing. That's a Toyota Corolla, and the Corolla is one of the best-selling vehicles in history for a reason. Better than a bicycle, as long as effort isn't the goal.

Perplexity.ai came along and felt like getting on a racing motorcycle. Same roads, dramatically faster. It pulls from the web, synthesizes answers, cites sources. People who discovered it started telling their friends that search was dead. And honestly, compared to pedaling a bicycle through ten blue links? They weren't wrong.

Google Search still works. The bicycle still rolls. You can still pedal your way to an answer. It's just that some people are driving now, and a few are on motorcycles, and many people think the motorcycle is the peak.

It's not.

Here's what all of those things have in common: you're driving. You sit down, you type, you steer, you read, you decide. The intelligence is in the engine but you are still the operator. You are still on roads. Every single one of those tools, from Google to ChatGPT to Perplexity, operates on the same fundamental layer. Call it the ground layer. You drive, it waits for you. Some ground vehicles are faster than others. Some have better GPS. But they're all bound by the same physics: you have to be in the seat.

What happened in January 2026 was not a faster car.

The Airplane Was Invented

Most people missed it. I almost missed it. The tech press covered it the way they cover everything: as a product launch, a feature update, a quarterly earnings talking point.

It wasn't. It was Kitty Hawk.

In the first weeks of 2026, agentic frameworks for synthetic intelligence went wide open. Open source. Freely available. The infrastructure for building systems that don't just respond to you but operate independently, persistently, with memory and goals and the ability to act while you sleep.

Not chatbots with extra steps. Something fundamentally different.

For the first time, synthetic intelligence left the ground. I don't mean it got faster. I don't mean it got smarter in the way that a motorcycle is faster than a bicycle. I mean it entered a layer of operation that didn't exist before. The way an airplane doesn't just go faster than a car. It operates in a dimension that cars don't have access to.

A Waymo on autopilot is still on roads. It's impressive. It hints at something. But it's still governed by intersections and lane markings and the two-dimensional surface of the earth. An airplane doesn't care about any of that. It operates above it.

That's what agentic synthetic intelligence did in January. It left the surface.

Six Weeks Later, We Have Jets

The pace after the airplane was invented has been, frankly, hard to process. Within weeks, the open source community took the prop plane and started building jets. The functional gap between what was possible in early January and what exists right now, in late February, is the kind of gap that normally takes years to cross.

Let me be specific.

I have a system running right now that "wakes up" at 5 AM and prepares a briefing for me. Not because I asked it to that morning. Because three weeks ago it asked me if that would benefit me and I told it that sounds good, so it built it, and it remembered. It pulls from live data sources, cross-references my calendar, checks the status of projects I'm running, and builds a summary that's waiting for me when I open my laptop or phone or whatever.

While I sleep, it manages a growing number of operational tasks across my digital infrastructures. It builds shared calendars from a live database. It monitors systems. It makes decisions based on context it has accumulated over weeks of interaction. It remembers a conversation I had with it about a specific client preference on February 3rd and applies that preference to a task it's executing on February 25th. Nobody reminded it. Nobody prompted it. It just knows, the way a good colleague knows.

This is not a faster car.

I don't drive this. I navigate it. I set headings and altitudes. It flies.

And this is the part that's hard to convey to someone who hasn't experienced it: the moment you go from driving to flying, you can't unfeel it. You look down at the roads and they're fine. They're still there. People are still driving on them and getting where they're going. But you're watching from a different altitude now, and the landscape looks completely different from up here.

The World Already Noticed (Even If You Didn't)

This isn't just my experience in a home lab. The ground is shaking under the entire software industry.

In the last month, the biggest names in SaaS (Software as a Service for the more senior readers;) collectively lost over $730 billion in market value, so far. Salesforce. Adobe. Microsoft. SAP. ServiceNow. Oracle. Not because their products broke. Because investors looked up and saw airplanes.

The seat-based subscription model that powered the entire SaaS industry for twenty plus years is facing something it has never faced before: systems that don't need seats. When a synthetic intelligence agent can navigate a complex software interface, process invoices, handle tier-one support tickets, manage CRM entries, and do it around the clock without a login, the math on "per user per month" starts to collapse.

Enterprises are already making moves. Reports surfaced in January of Fortune 50 companies planning to cut their software licensing spend by more than half, replacing human-operated software seats with agent-driven API access to the same underlying systems. Not in five years. This year.

The SaaS model isn't dying because it was bad. It's dying because it was built for the ground layer. It assumed a human would always be in the seat. That assumption just met an airplane.

Pricing models are scrambling to adapt. Usage-based. Outcome-based. Per-agent billing, like a salary for a digital worker. The old model of charging for how many humans touch your software doesn't make sense when the thing touching your software isn't human. The industry knows this. It's not a secret. It's a $1 trillion repricing happening in real time.

And the frameworks that enabled all of this? They're open source. Freely available. LangGraph, CrewAI, AutoGen, Mastra, AgentZero, OpenClaw, dozens more. The building blocks of flight are sitting on GitHub right now, being downloaded millions of times per month. The blueprints for the airplane are public. The lumber and canvas and aluminum are free.

This is not a closed technology owned by three companies in San Francisco. This is the printing press. The source code is available to anyone willing to learn.

What the Skeptics Are Actually Afraid Of

I know there are people reading this who are already composing their objections. I know because I've been one of those people for most of my career. The eye-roll is earned. If you've watched twenty years of hype cycles, if you bought into Blu-ray or NFTs or the metaverse or Zune, or any of the other things that were supposed to change everything and didn't, your skepticism is pattern recognition. And pattern recognition is usually a good instinct.

But here's the thing about pattern recognition: it can also blind you to the pattern break.

The bicycle, the car, the motorcycle, the self-driving car on autopilot. Those were all iterations within a pattern. Faster ground transportation. Better ground transportation. The airplane broke the pattern entirely. It didn't iterate. It escaped.

Some of the skepticism is healthy caution. Some of it, if I'm being honest, is something else. It's fear. And not the kind of fear most people do not like to admit to.

For a lot of people, their work or role became their identity. That's a common human pattern. When you spend fifteen years getting good at something, when your expertise is the thing that makes you valuable, when your skill set is the answer to "what do you do," a technology that can operate in your domain without needing you in the seat seems like an existential one.

This has happened before. Every time.

The scribes who copied manuscripts by hand were the highly skilled knowledge workers of their era. Oh the pride they must of had in their work. The printing press didn't just take their jobs. It made the thing they were proud of, the thing that they believed defined them, ordinary. Coders might want to sit with that comparison for a minute.

The monks didn't stop being valuable humans when Gutenberg fired up the press. But their particular "specialness", the thing that made them irreplaceable, changed.

What's happening right now is bigger than any one profession. It's a challenge to the idea that humans are special because of what we can do. Because for the first time, the thing in the air can do a lot of what we do. Not all of it. Not the parts that matter most, probably. But enough of it to make people uncomfortable in a way they haven't been before.

The ones who built their identity entirely on capability, on what they could produce, are having a hard time right now. I don't blame them. But pretending the airplane doesn't fly because you don't like what it means for your bicycle shop, or your video rental store (i'm looking at you Blockbuster;), is not a strategy.

December 1903

Here is a historical fact that should keep you up tonight.

The Wright Brothers flew at Kitty Hawk in December 1903. Twelve seconds. 120 feet. A prop plane made of wood and fabric that barely got off the ground.

Eleven years later, in 1914, military aircraft were being used in World War I.

Sixty-six years after Kitty Hawk, humans walked on the moon (or so we were told;).

Sixty-six years. From a wooden prop plane that flew the length of a football field to Neil Armstrong stepping onto the lunar surface. One human lifespan.

The curve after invention is always, always steeper than anyone predicts. People at Kitty Hawk who watched that twelve-second flight could not have imagined a 747. They couldn't have imagined a fighter jet. They couldn't have imagined satellites. The thing they were watching was so primitive, so fragile, so early, that the reasonable response was to underestimate what it would become. And every single one of them would have been wrong.

We are at December 1903 right now.

The agentic synthetic intelligence systems that exist today are the wood-and-fabric prop plane. They are remarkable, and they are primitive. Both things are true. What I built, what I'm using every day, what wakes me up with a briefing and manages my operations while I sleep, is astonishing to me. And I know, with the certainty of someone who has watched six technology waves break, that what I have right now will look like a toy in two years.

Whatever you think this looks like in five years, you are underselling it. I am underselling it. We don't have the imagination for what comes after the airplane exists, because we've been on the ground our whole lives.

You Don't Have to Be a Pilot

Here's where I want to end, and I want to end with you, not me.

The airplane didn't stay exclusive to the Wright Brothers. It didn't stay exclusive to aviators or the military or the wealthy. Within decades, it changed how every single human being on earth moved through the world. You didn't have to be a pilot. You didn't have to understand aerodynamics. You just had to know that buying a plane ticket would get you across an ocean in hours instead of weeks.

You don't need to build what I built. You don't need to understand LangGraph or agentic frameworks or synthetic intelligence architecture. That's my job. That's what I do.

But you should know the airplane exists.

The Corolla is still a good car. Take it to work. The bicycle still gets you to the corner store. Perplexity is a hell of a motorcycle. None of those things are broken.

Just know that there's a runway now. And some of us are already in the air. Some of us are climbing. And a few of us, if I'm being completely honest, are up here trying to figure out how to land, because that part was not exactly covered in our crash-course flight training last month.

The ground looks different from up here. Not worse. Not scary. Just bigger than I thought it was.

Come find the runway when you're ready. It's open. It's free. And the sky, as it turns out, is not the limit. It's just where it starts.

Brian has been building, breaking, and rebuilding technology systems for over 30 years. He writes at b-tec.org.

The 3-Layer Memory System That Turns Your AI Agent Into a Digital Twin

b-tec — Thu, 26 Feb 2026 16:46:03 +0000

The 3-Layer Memory System That Turns Your AI Agent Into a Digital Twin

Part 2 of 2 in the "Why Your AI Agent Has Amnesia" series

After studying how some of the most advanced OpenClaw users are running their agents, one pattern kept showing up. Not a specific tool. Not a prompt hack. An architecture for memory that, once wired in, fundamentally changed what the agent could do.

If you read Part 1, you already know the problem: agents without structured persistent memory forget everything between sessions, repeat questions, lose track of their own work, and constantly pull you back in as the bottleneck. Here's how to fix it. (full disclosure, I'm still live testing this. always testing everything:)

The 3-Layer System (Based on Tiago Forte's P.A.R.A.)

The insight behind this approach borrows from Tiago Forte's P.A.R.A. framework for organizing knowledge, adapted for how AI agents actually retrieve and use information. Instead of one monolithic memory file, you split memory into three distinct layers, each with its own purpose and structure.

Layer 1: Daily Notes (memory/YYYY-MM-DD.md)

This is the working log. Each day gets its own markdown file that captures what happened during that day's sessions: tasks completed, decisions made, errors encountered, open questions. Think of it as a project journal. The agent writes to it throughout the day, and the file becomes the raw material for everything downstream.

The key constraint: daily notes are append-only during the active day. The agent never edits previous days' notes directly. This keeps the log honest and prevents retroactive rewriting of history.

Layer 2: Knowledge Graph (memory/knowledge/)

This layer stores structured facts about entities in your world: projects, services, API pointers, team members, infrastructure components. Each entity gets its own file or section. When the agent needs to know "what database does the billing service use?" or "what's the endpoint for our Stripe webhook?", it looks here.

Knowledge graph entries are durable and canonical. They get updated when facts change, but they represent the current state of truth. This is where your agent builds its understanding of the environment it operates in.

Layer 3: Tacit Knowledge (memory/tacit/)

This is the most underappreciated layer. Tacit knowledge captures how things work around here: your coding preferences, deployment rituals, security rules, naming conventions, lessons learned from past mistakes, and patterns that should be followed or avoided.

Tacit knowledge is what separates a generic assistant from a digital twin that actually operates the way you would. When the agent knows that you always want error handling in a specific style, or that a particular API has a quirk that requires a workaround, or that deploys to production should never happen on Fridays, it can make better decisions without asking you.

Why the separation matters. When the agent needs information, the right layer gets searched based on what kind of question is being asked. "What did I do yesterday?" hits daily notes. "What's the schema for the users table?" hits the knowledge graph. "How do we handle retries on this service?" hits tacit knowledge. Searching everything at once wastes tokens and returns noisy results. Layered retrieval keeps things fast and relevant.

The Nightly Consolidation Cron

Here's where the architecture really starts to compound. The daily notes are raw material, but raw material alone doesn't build long-term intelligence. You need a process that reviews, extracts, and distributes knowledge from the day's work into the durable layers.

The solution is a cron job that runs every night at 11pm (or pick a time that works for you). It opens the day's sessions and daily notes, then performs four extraction passes:

Decisions made. What was decided, and why? These get filed into the knowledge graph under the relevant entity.
Tasks completed. What shipped? What was resolved? The daily note gets a summary, and relevant knowledge files get updated to reflect the new state.
New knowledge discovered. Did the agent learn something about the infrastructure, an API, or a dependency? That goes into the knowledge graph.
Open items and blockers. What's still pending? These carry forward into the next day's context so the morning session starts with full awareness of unfinished work.

The consolidation cron also prunes contradictions. If Tuesday's session established that the API uses v2 endpoints, but Thursday's note still references v1, the cron reconciles and updates the knowledge graph to reflect the current truth.

The compounding effect here is significant. After a week of nightly consolidation, your agent's knowledge base is materially richer. After a month, it knows your infrastructure with a depth that would take a new team member months or years to develop. Your agents will be smarter every single morning.

memU: The External Vector Store

The file-based memory system works well for structured, entity-level knowledge. But as your agents accumulate months of daily notes and dozens of knowledge files, local file search starts to hit its limits. Grep and keyword matching can't handle the semantic nuance of questions like "when did we last deal with a rate limiting issue on the payments API?"

This is where memU comes in as the long-term semantic memory layer. memU is a vector store that indexes your agent's entire memory corpus and supports natural language retrieval. When the agent has a question, it queries memU first, gets back the most relevant passages, and only falls back to file-level search if memU doesn't surface what it needs. Keep memU local and backed up. It will persist across any OpenClaw updates or any other changes in the stack.

The retrieval hierarchy looks like this:

memU query for intelligent semantic search across all memory layers
memory_search for structured keyword and path-based lookups
Direct file reads only when the agent needs the full content of a specific known file

This hierarchy is critical for token efficiency. Instead of reading entire files to find a single fact, the agent gets precisely the passages it needs. Sessions start faster, run longer before hitting context limits, and waste far less compute on re-reading information the agent already processed days ago.

Wiring the Heartbeat to the Memory

If you've followed the OpenClaw Operator's Guide, you already know about the heartbeat: the periodic check that monitors your agent's running sessions and restarts them if they die. The memory system makes the heartbeat dramatically more powerful.

With daily notes in place, the heartbeat can read the current day's log to understand what's in flight. The logic becomes:

Check if there's an open project or task in today's daily note.
Check if the session assigned to that task is still running.
If the session died, restart it silently with full context from the daily note.
If the session completed, log the result and surface it in your next briefing.

This is how your agent stays on top of long-running work without you watching over it. A six-hour refactoring job that crashes at hour four? The heartbeat catches it, restarts the session, and the agent picks up where it left off because the daily note captured everything up to that point. You wake up to a completed task instead of a dead process.

The Payoff

When memory compounds over weeks and months, the texture of your interactions with the agent changes fundamentally. You stop repeating yourself. You stop re-explaining your infrastructure. You stop answering the same configuration questions. The agent handles longer autonomous runs because it has the context to make decisions without checking in.

Your morning briefing actually briefs you, because the agent knows what happened yesterday, what's still open, and what needs your attention. Your build sessions move faster because the agent remembers your patterns, your preferences, design principles, and the lessons from past mistakes.

This memory system is the foundation layer. Everything else you want to build on top of OpenClaw (API integrations, automated cron workflows, product development pipelines) scales on this foundation. Without it, you're rebuilding context every session. With it, you're compounding capability every day.

Getting Started

You don't need to build all three layers and the consolidation cron and memU in a single weekend. Start with Layer 1. Create the memory/ directory and a daily note template. Have your agent write to it during every session. That alone will make your next-day sessions feel completely different.

Once daily notes are flowing, add the nightly cron to extract knowledge into Layers 2 and 3. Then wire in memU when the file count gets high enough that keyword search stops cutting it.

Each layer you add makes the previous ones more useful. And the day your agent opens a morning session, reads its own notes, checks on overnight tasks, and briefs you on what needs attention without a single prompt from you? That's the day you stop thinking of it as a tool and start thinking of it as a teammate.

Too tired from reading all this or feeling overwhelmed? No worries, just share this post with your agent and once you agree on an approach that works for you, have the agent get it all setup.

Shells Up! Happy Building!

b-tec

Your AI Agent Forgets Everything. Here's Why That's Killing Its Potential.

b-tec — Thu, 26 Feb 2026 16:45:47 +0000

Part 1 of 2 in the "Why Your AI Agent Has Amnesia" series

You've got OpenClaw running. It's impressive. You watched it scaffold a project, write tests, and deploy to staging in under an hour. But then after a couple weeks, you opened a new session and slowly felt that familiar deflation. The agent had no idea what happened yesterday. It asked you for the same API keys. It re-read files it had already analyzed. Every session feels like meeting an old neighbor who vaguely knows your name.

This is an architecture problem, and until you solve it, your agent will never reach its actual potential.

What "Memory" Actually Means in an AI Agent

When most people talk about an AI agent's "memory," they're actually describing the context window. The context window is the rolling buffer of text the model can see during a single session. Think of it like a whiteboard in a meeting room: useful while you're in the room, erased the moment you leave.

Real memory is persistent. Real memory survives between sessions, accumulates over time, and gives the agent a foundation of knowledge it can build on without starting from scratch.

The distinction between these two things matters enormously, and collapsing them into one concept is where most setups go wrong.

The default approach for many OpenClaw users is a single MEMORY.md file. The agent reads it at the start of a session, appends notes as it works, and theoretically carries knowledge forward. In practice, this falls apart fast. The file grows without structure. Important facts get buried under session logs. Contradictory information piles up because nothing ever gets pruned or reconciled.

Then there's the compaction trap. When the context window fills up, the agent has to summarize or drop older content to make room for new input. Every compaction cycle loses detail. After enough cycles, the agent has forgotten critical decisions, skipped over established patterns, and reverted to behaviors you corrected hours ago. The "memory" becomes a lossy compression of itself.

Why This Matters More Than You Think

Every fact your agent forgets is a question that lands back on you. Every dropped context is a bottleneck that pulls you out of whatever you were actually doing. You end up babysitting a system that was supposed to free up your time.

Nat Eliason, one of the more advanced OpenClaw operators publicly documenting his work, framed this perfectly when he described the core question of agent design: "Can I remove this bottleneck for you?" Autonomy scales directly with memory. An agent that remembers your infrastructure, your preferences, your project state, and the decisions you've already made together can operate independently for hours. An agent that forgets all of that every time the session resets? You're going to spend half your day re-explaining things.

Without good memory, you don't really have an agent. You have a very fast search engine that occasionally writes code.

The Failure Modes (Real Examples)

These aren't hypotheticals. These are patterns that show up constantly in the OpenClaw community.

The repeated credentials request. You gave the agent your Stripe API key in the morning session. By the afternoon session, it asks again. The next day, same thing. The key was in a .env file the entire time, but the agent lost track of where it stored credentials and what was already configured.

The vanishing marathon session. You kicked off a deep refactoring task that ran for six hours. The agent made dozens of decisions, restructured three modules, and updated the test suite. The next session opens with zero awareness that any of this happened. You're left piecing together what changed by reading git diffs.

The groundhog-day briefing. You set up a morning check-in routine. Every morning, the agent is supposed to summarize what's in flight and surface blockers. Instead, it starts from absolute zero every single day. No awareness of yesterday's progress. No memory of open pull requests. No recall of the deployment that failed at 2am.

The stalled project. A multi-day project grinds to a halt because the agent can't locate its own prior work. It wrote a utility function on Tuesday, forgot about it on Wednesday, and wrote a slightly different version on Thursday. Now you have duplicate logic scattered across the codebase and an agent that doesn't know which version is canonical.

Every one of these failures traces back to the same root cause: the agent has no durable, structured memory system.

What Comes Next

There's a pattern that fixes all of this. The architecture is straightforward, and some of the most effective agentic developers are already using it. You do have to build it deliberately, though, because nothing in the default setup gives you real persistence.

In Part 2, we'll break down the three-layer memory system, the nightly consolidation cron that makes your agent smarter every morning, and the external vector store that handles long-term semantic recall. Once these pieces are in place, everything else you want your agent to do — API integrations, automated workflows, product building, role building, company building — finally has a foundation to scale on.

[Part 2 will be posted tomorrow)

This is part of the OpenClaw Operator's Guide series on b-tec.org. If you're running into these memory problems right now, Part 2 has the fix.