Abstract Executing autonomous AI agent payloads in Google Workspace via the Apps Script...

China's Zhipu AI (Z.ai) released its open-weight GLM-5.2, and some researchers have claimed that it matches Mythos in certain bug-finding and cybersecurity scenarios. While GLM lags behind models from Anthropic and OpenAI in other, more general tasks, it seems that China has dramatically reduced the gap in the capabilities between its models and those of […]

Streaming ads might be getting a lot quieter.

The day before Father's Day, my daughter walked into her first swimming lesson like she owned the place. She'd been dreaming about water for as long as I can remember. Barely gets exposure to it. Walked in, took to her teacher without hesitation, spent thirty minutes in an environment she loves, had a blast the entire time. All the worry I'd carried into that morning dissolved in about four seconds. Father's Day itself was quiet after that. Easy. The kind of day where you have space to pick up something you've been thinking about and actually finish it. I shipped rfd-logging to PyPI. It's a logging standard. One get_logger call. Structured JSON output. Ten megabyte rotation, five backups, stdout capture for NSSM services. Zero runtime dependencies — pure Python standard library. Forty-six tests. The kind of thing that takes an afternoon to build once you know what you want, and takes two years of building other things before you know what you want. That's the honest timeline. Over a hundred projects. Probably closer to five hundred if you count everything back far enough. Logging handled differently in every one — sometimes print statements, sometimes a library, sometimes nothing at all. Each project reinventing the same wheel slightly differently. The friction was always there. It took two years to feel it clearly enough to do something permanent about it. My second PyPI release. The first was openagent-directive — a different kind of primitive, built for a different problem. This one is smaller and more universal. Every project needs logging. Not every project needs an agent directive system. rfd-logging is the kind of package that belongs in every RFD service from day one, and eventually in anything I build regardless of context. That's what shipping to PyPI teaches that shipping locally doesn't. The question stops being "does this work for this project" and becomes "would someone else find this useful." Building with reusability in mind from the start changes th

Would you trust a sci-fi author to program critical AI systems for humanity? No? Yet, that's what we've been doing. Years ago, I remember hearing the argument: "Why don't we just prompt LLMs with Asimov's three laws of robotics ?" It sounds elegant. The laws were designed to constrain artificial minds. Why not use them? Because the model has already read every story where they fail. LLMs are statistical engines designed to autocomplete text. Imagine a story that starts like this: Once upon a time, there was a good little robot who followed the 3 laws of robotics to the letter. Now take human literature and complete the story. Does it end well? ‹ › (function() { var container = document.currentScript.closest('.ltag-slides--carousel'); var track = container.querySelector('.ltag-slides__track'); var slides = track.querySelectorAll('.ltag-slide'); var prevBtn = container.querySelector('.ltag-slides__nav--prev'); var nextBtn = container.querySelector('.ltag-slides__nav--next'); var dotsContainer = container.querySelector('.ltag-slides__dots'); var current = 0; var total = slides.length; for (var i = 0; i < total; i++) { var dot = document.createElement('button'); dot.className = 'ltag-slides__dot' + (i === 0 ? ' ltag-slides__dot--active' : ''); dot.setAttribute('aria-label', 'Go to slide ' + (i + 1)); dot.dataset.index = i; dot.addEventListener('click', function() { goTo(parseInt(this.dataset.index)); }); dotsContainer.appendChild(dot); } function goTo(index) { current = ((index % total) + total) % total; track.style.transform = 'translateX(-' + (current * 100) + '%)'; var dots = dotsContainer.querySelectorAll('.ltag-slides__dot'); for (var i = 0; i < dots.length; i++) { dots[i].classList.toggle('ltag-slides__dot--active', i === current); } } prevBtn.addEventListener('click', function() { goTo(current - 1); }); nextBtn.addEventListener('click', function() { goTo(current + 1); }); })(); It doesn't. Because the entire body of fiction built around those laws exists to explo

Your AI coding agent writes something that looks right. It compiles in your head. Then you notice it called user.getProfileById() — a method that doesn't exist anywhere in your codebase. You didn't ask it to make that up. It invented it confidently, in the middle of otherwise-fine code. And that's the worst kind of wrong: not obviously broken, just quietly incorrect in a way you have to catch. If you've run Claude Code, Cursor, or any agent on a real repo, you know this one. Here's why it happens — and why the obvious fix doesn't work. The fix everyone tries first (and why it fails) You reword the prompt. You add "Don't make up functions." It behaves… for one file. Then it does it again. So you add "Only use methods that exist in the provided code." Better for a bit. Then two more sentences — and now your prompt is fifteen rules long and it still invents a method the moment the task gets complex. Here's the part nobody tells you: rewording treats a structural problem as a vocabulary problem. A prompt isn't a contract the model reads once and obeys. It's something the model has to hold in working memory while it reasons about your actual task. A flat list of fifteen rules is unholdable. As the work gets harder, the model spends its attention on the code and quietly drops whichever rule wasn't front-of-mind. "Don't invent methods" is usually rule #11. Under load, it falls out. You can't out-word that. A sixteenth rule just gives it one more thing to drop. The actual cause: shape, not wording The agent invents a method because nothing in the prompt's structure requires it to check. You told it what not to do. You never changed what it actually does, step by step. So stop forbidding the bad thing. Remove the opportunity for it. Instead of a rule it has to remember, make grounding a required step it has to perform. Before — a pile of rules:You are an expert engineer. Write clean code. Follow our conventions. Don't make up functions. Only use methods that exist. Handle er

Last night I was deep in a build session with an AI assistant. We picked it back up tonight. At some point I mentioned it had been a day and a half since we last spoke — and the model had no idea. None. As far as it knew, it was still the previous session. The gap was invisible to it. That tiny moment is one of the most underrated problems in AI systems right now. So let's talk about it. The model doesn't know what time it is An LLM gets a rough sense of "now" at the start of a conversation — a single timestamp, handed to it once. That's why it can greet you with "good morning." But that stamp is frozen. It doesn't update as the conversation runs, and it definitely doesn't travel into the next conversation. Each session starts cold. On its own, that's a curiosity. It becomes a real problem the moment the model reasons over retrieved context — search results, documents, database rows, another agent's output. Staleness is invisible Here's the dangerous part. When a model reads a retrieved document, that document usually carries no trustworthy signal about when it was true . So the model treats it as present-tense. It produces a confident answer from six-month-old data with nothing flagging that the data is old. A few places this bites: Pricing — quoting a number that changed last quarter. Availability — "in stock" from a cached page. Compliance — citing a policy that was superseded. People — stating someone's job title from two years ago. For a human reader, a slightly stale search result is fine — you see the date and judge for yourself. For an LLM, the staleness is silent. The wrong answer looks exactly like a right one. Why "just add a clock" doesn't fix it The instinct is: give the model the current time. But knowing it's 9 PM doesn't help if the document you're citing went stale in 2023 and nothing told you. The missing piece isn't the model's clock — it's the context's freshness . Two different things: What time is it now? — easy, a now() call solves it. How old

Performance optimization has always been one of the hardest parts of web development. You run...