I Have Something I Need to Confess...

TL;DR: I’m an OpenClaw maintainer. I’ve been (sort of) hiding it since I started. The recruiting spam, the harassment, the “are you hiring?” DMs — they’re real and they’re relentless. But with Artemis II slipping to April, I finally have bandwidth. I’ve been shipping PRs, building specs, and I’m done being quiet about it.

“Three may keep a secret, if two of them are dead.” — Benjamin Franklin

Well, Ben, it’s been a few months. I’m still alive. And I can’t keep this one anymore.

I’m an OpenClaw maintainer.

There. I said it. I know some of you suspected.

Let me explain why I’ve been lying low — and what I’ve been building while nobody was looking.

First, I was honored when Peter suggest I become a maintainer. For the first ~month I had significant non-claw work I needed to finish, so I didn't want to say much. Felt like potential stolen valor. And also...

The Bill Wyman Problem

Peter Steinberger is Mick Jagger. He’s the frontman. The one everyone sees strutting across the stage, lips pursed, microphone in hand, 80,000 people (or 2 million users) screaming. Peter is OpenClaw, and rightfully so.

I’m Bill Wyman.

Does anyone even know who that is? Wyman was the bass player in the Rolling Stones from 1962 to 1993. His nickname was “The Quiet One.” He stood in the back, kept his head down, and held the rhythm together while Mick and Keith got all the headlines. To be even more clear, Peter wrote 85%+ of all the code. The rest of us wrote ~15%. I wrote perhaps ~0.3%.

“I was just the bass player. Mick was the star. Keith was the rebel. I was the one who showed up on time.” — Bill Wyman

That’s been my vibe since I started as a maintainer. Show up. Work on hard problems. Occasionally PR and merge code.

I'm a small part of a massive success.

Why the Silence?

Because OpenClaw maintainers are targets.

The recruiting emails are relentless. The “quick 15-minute call” requests are infinite. The harassment from people who think open-source maintainers owe them something — that’s a whole separate blog post I’ll write someday when I’ve had enough bourbon.

Nadia Asparouhova (née Eghbal) documented this brilliantly in Working in Public: the paradox of open-source fame. You build something people love, and your reward is that strangers feel entitled to your calendar, your attention, and your emotional labor.

“The problem with open source is that the better you do, the more work you create for yourself.” — Nadia Asparouhova, Working in Public

So I stayed quiet. Contributed where I could. Avoided the spotlight. The bass player strategy worked — until it didn’t.

Where I’ve Been
(It's not Rocket Science. Oh wait.)

I haven’t shipped as much as I’d like in the last six weeks because I’ve been preparing for my role supporting the NASA Artemis II launch. Even in a support capacity, preparing for humanity’s return to the Moon is — and I cannot stress this enough — a lot of work.

With Artemis II recently slipping to April, I suddenly have breathing room. And I intend to use every minute of it.

“The best time to plant a tree was twenty years ago. The second best time is now.” — Chinese Proverb

My tree-planting season just started.

What I’ve Been Building

OpenClaw Core: The Plumbing Nobody Sees

I submitted PRs for critical fixes in the OpenClaw core — the kind of work that doesn’t make headlines but prevents your AI agent from silently eating its own output:

• fix(agent): propagate LLM stop reason through lifecycle events — When an LLM stops generating, the reason it stopped matters. Was it done? Did it hit a token limit? Did safety filtering kill it? This PR ensures that signal propagates correctly through the entire agent lifecycle instead of getting swallowed. Boring. Essential.
• fix(gateway): flush throttled delta before emitChatFinal — A race condition where the gateway would emit a “chat complete” event before flushing the last chunk of actual content. Your agent would think it was done talking before it finished its sentence. The kind of bug that makes you question reality at 2 AM.

Both of these touch the Agent Client Protocol (ACP) subsystem — the open protocol co-developed by Zed and JetBrains that standardizes communication between code editors and AI coding agents. ACP is what lets any editor — Zed, IntelliJ, PyCharm, WebStorm — connect seamlessly to any AI agent.

ACP is actually where a great deal of my time goes. I wrote the ACP server implementation in OpenClaw — the piece that makes OpenClaw speak ACP natively. Peter then rewrote parts of it, and he merged it as a jointly authored PR. That’s the dynamic: We lay the foundation, Peter comes through and makes it Peter-grade, and the project ships something neither of us would’ve built alone. Bass player lays down the groove, Mick makes it a hit. Getting the plumbing right matters.

gogcli: Teaching OpenClaw to Write Documents

gogcli is arguably the most-used plugin in the OpenClaw ecosystem. It’s the bridge between OpenClaw and Google Workspace — Gmail, Calendar, Drive, Docs, Sheets. Peter also made me a maintainer of gogcli. Another honor. It's a very cool tool.

I’ve now merged three PRs into gogcli:

1. feat(docs): add sedmat — sed-like document formatting DSL — The big one. This enables gogcli to create and modify any Google Doc using a compact, deterministic DSL. Sheets and Slides support are coming next.
2. fix(calendar): add timezone to EventDateTime for recurring events — Recurring events without timezone data is how you get your 9 AM standup showing up at 2 AM in Tokyo. Fixed.
3. feat(comments): Add drive comments subcommand — Because collaboration requires conversation, even when your collaborator is an AI agent.

sedmat: A Specification I’m Proud Of

I’ll confess something else: I enjoy creating standards and specifications almost as much as I enjoy writing code.

“Standards are always out of date. That’s what makes them standards.” — Alan Bennett

(Though I have to admit — in the age of agentic coding, claiming credit for code feels increasingly like a professor taking credit for their doctoral students’ work. Specifications, though? Those are still mine.)

I created sedmat.org — Sed-Expression-Driven Markup Annotation & Transformation — before and while making the gogcli changes. And I think it matters more than the code itself.

Here’s why.

If you’ve ever watched an AI agent try to edit a document, you’ve seen the problem. As I wrote in my MCP piece, LLMs work best when given small, composable, deterministic tools — the Unix philosophy, applied to everything. But document editing is one of the hardest problems for agents because documents aren’t text files. They’re deeply nested trees of structural elements, formatting runs, inline objects, and positional indexes.

An LLM trying to edit a Google Doc through the raw Docs API is like asking someone to perform surgery by describing each hand movement in JSON. It’s technically possible. It’s also insane.

sed solved this for text files in 1974. Lee McMahon at Bell Labs created a stream editor that let you express precise, surgical text transformations in a compact notation:

s/old/new/g

That’s it. Find old, replace with new, do it everywhere. No ceremony. No 47-field JSON payload. Just intent, expressed cleanly.

“Everything should be made as simple as possible, but no simpler.” — Albert Einstein (paraphrased)

sedmat extends this philosophy into structured documents — but it goes far beyond simple find-and-replace. The real power is in the brace-based formatting DSL. This is where it stops being sed and becomes something new.

Formatting, Not Just Editing

Traditional sed can only manipulate plain text. sedmat can manipulate rich text. The brace syntax {flags} gives agents a compact vocabulary for expressing formatting intent:

# Make every uppcase NOTE --> note
s/NOTE/note/g

# Make every note a bold warning
s/warning/{b t=$0}

# But we don't need the $0 aka \0 because $0 is the default for t=
# so this also bolds warning
s/warning/{b}/g

# Bold + red
s/error/{b c=red}/g

# Wrap text in a hyperlink
s/Google/{u=https://google.com}/

# Turn a line into a heading
s/Introduction/{h=1}/

# Delete every paragraph containing "DRAFT"
d/DRAFT/

Think about what’s happening here. An AI agent can express “make all warnings bold and red” in a single line — s/warning/{b c=red}/g — instead of navigating the Google Docs API’s labyrinth of UpdateTextStyleRequest objects with TextStyle fields, Range specifications, and FieldMask declarations. That single sedmat expression compiles down to potentially dozens of API calls — find every instance, calculate the character offsets, construct the style objects, batch the requests. The agent never sees any of that complexity.

“The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise.” — Edsger Dijkstra

sedmat supports the full spectrum: bold, italic, underline, strikethrough, colors, font sizes, headings (h1–h6), blockquotes, code blocks, horizontal rules, lists, tables, inline images, and hyperlinks. It handles structural operations like append (a/), insert (i/), and transliterate (y/). It supports full Extended Regular Expressions with back-references. It supports batch processing via pipelines, heredocs, and file-based expression sets. It even has a dry-run mode — because no one wants an AI agent reformatting a 200-page contract without a preview.

Doug McIlroy, the inventor of Unix pipes, said it best:

“Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.”

sedmat is a text stream interface for rich documents. I think it's rather beautiful. Compact yet complete. It's not something you can just vibe-code into existence. McIlroy would approve.

(I hope.)

Beyond Google Docs

Here’s the big thing: sedmat is platform-agnostic by design. The specification targets any rich document format — Google Docs, Microsoft Word, Slides, PowerPoint, Sheets, Excel. The expressions are the same. Only the compilation target changes.

I’m already bringing sedmat to mogcli — the Microsoft Open Graph CLI for Mail, Calendar, OneDrive, and Office 365 — and sogcli — the Standards Opps Gadget for open protocols like IMAP, SMTP, CalDAV, CardDAV, and WebDAV. Same sedmat expressions, different backends. Write once, format anywhere.

# This same expression works across Google Docs, Word, and any future target:
s/Q1 Revenue/{b c=green h=2}/

But the applications I can imagine are only part of the story. sedmat is a specification, not a product. As Stewart Brand wrote: “A building is not something you finish. A building is something you start.” Specifications work the same way — you plant them, and other people grow things you never imagined.

Could someone build a sedmat-powered Notion plugin? A Confluence integration? A Markdown-to-WYSIWYG migration tool? An accessibility formatter that scans documents and applies WCAG-compliant color and heading structures in one pass? A legal redlining tool that expresses contract edits as diffable, auditable sedmat expressions instead of opaque “Track Changes” blobs?

I can imagine those. Others I can’t. And that’s the point.

“The best way to predict the future is to invent it.” — Alan Kay

I invented the interface. The implementations (waves hands at world) are up to you.

This is what I wrote about in 100 Future Fortnights — interfaces are contracts, implementations are kindling. sedmat is an interface. The Google Docs API calls underneath it? Kindling. The Microsoft Graph calls? Also kindling. Burn them and rebuild whenever you want. The sedmat expressions will still work.

“Simplicity is the ultimate sophistication.” — Leonardo da Vinci (misattributed, but still true)

What’s Next

I’m committing significant time to OpenClaw moving forward. This is in addition to my board positions and my companies:

• Sighthound — Computer vision, AI redaction, license plate recognition, and edge compute hardware for law enforcement and enterprise video privacy
• Deft.co — a succinct, efficient, elegant Agentic Development Environment (ADE) for high-performance software at any-scale (you can read more about 1/7th of Deft at deft.md)
• Cambiar.ai — Where I’m applying everything I’ve learned about AI-native software to help others adopt AI – at a company started byJason Goecke, who was also the CEO of Tropo

It’s a lot. I know. As Marc Andreessen once said: “Software is eating the world.” I’d update that:

Software is eating the world,
Open-source is eating software,
AI is eating open-source,
and the people building it
Are running on concentrated caffeine and conviction.

Why OpenClaw Matters — Really Matters

I wrote MCP is Evil in part because I believe the AI industry was heading in the wrong direction — toward centralized, bloated protocols that serve vendors more than builders. OpenClaw is the antidote.

But it’s bigger than protocols.

For years, “Big AI” — Anthropic, Google, OpenAI —[1] were mired in benchmark wars and risk theater. Endlessly measuring. Endlessly cautious. Endlessly telling us what we can’t do, what we shouldn’t build, what’s too dangerous to release.

“Of all tyrannies, a tyranny sincerely exercised for the good of its victims may be the most oppressive.” — C.S. Lewis

They meant well. (Most of them.) But the effect was the same: builders were suffocating under the weight of someone else’s risk calculus.

Then OpenClaw showed up and everyone’s eyes opened.

You know the scene in The Matrix Reloaded where Zion throws the rave? The machines are drilling toward the last human city. Everyone knows the existential risks are real. The Sentinels are coming. Destruction is plausible, maybe probable.

And what do the citizens of Zion do?

They dance.

Not because they’re in denial. Because they’ve decided that freedom — messy, dangerous, uncertain freedom — is worth celebrating. Because being alive means something only when you’re free to choose what you do with that life.

“You do not truly know someone until you fight them.” — Seraph, The Matrix Reloaded

OpenClaw is that rave. Everyone building on it knows the risks. AI safety is real. Alignment is unsolved. The Sentinels are drilling. But for the first time, builders are free — free to experiment, free to push boundaries, free to build without Big AI’s permission slip.

And that freedom is producing better, faster, more creative work than any safety committee ever could.

“Freedom is not worth having if it does not include the freedom to make mistakes.” — Mahatma Gandhi

One Last Confession

I started this post by saying I had something to confess. But the real confession isn’t that I’m a maintainer. It’s that I love this work. Not “enjoy” it. Not “find it professionally rewarding.” Love it. The way you love something that makes you lose track of time, skip meals, and forget to sleep.

The 6502 assembly code I wrote as a kid. The Pascal programs in high school. The C, the JavaScript, the SaaS metrics, the finance structures, the venture deals, the mergers, acquisitions, exists, and investments — they were all leading here. To this moment. To building tools that make other builders more powerful.

“We are what we repeatedly do. Excellence, then, is not an act, but a habit.” — Will Durant (paraphrasing Aristotle)

I’ve been doing this my whole life. I just finally found the project worthy of going public about.

Long Live the Lobster King. 🦞

[1] In case you are questioning the human authory-ness of this post; I've been writing with em-dashes since 1988, and I have the receipts in glorious 1987 Pagemaker for Mac publications to prove it.