DEV Community: AI Pulse

AI Agents Can't Be Trusted With Their Own Keys: Brex's CrabTrap, HalluSquatting & the Robot Phone

AI Pulse — Mon, 20 Jul 2026 03:03:55 +0000

Brex's CrabTrap, HalluSquatting, and Why Your AI Agent Can't Be Trusted With Its Own Keys

Three stories hit the AI security world this week, and they tell you more about where we're heading than any model release ever could.

Let me start with the one that kept me up.

Brex built a proxy called CrabTrap that watches what AI agents actually do on the network, then drafts security policy from observed behavior — not from some whiteboard session where nobody admits their agent talks to sketchy APIs.

Honestly, this is the first enterprise AI security approach that makes sense to me. Most teams are still doing the equivalent of handing their agent a keychain with every key on it and saying "just be careful." Brex's co-founder Pedro Franceschi put it well: the more capable you make an agent, the more dangerous it becomes, and the safer you make it, the less useful it is. That tension isn't going away.

CrabTrap sits at the transport layer — HTTP_PROXY, HTTPS_PROXY, that's it. Framework-agnostic, language-agnostic. Every outbound request routes through it. An LLM judge (Claude Haiku, small and fast) only fires on the long tail of unfamiliar endpoints, which for a mature agent is less than 3% of requests. The rest become static rules from observed behavior.

The key insight? Bootstrap policy from what agents actually do, not from what you think they should do. Start with real behavior, edit down. That's dramatically more effective than a blank page.

Now pair that with this week's other big security story.

HalluSquatting is what researchers are calling it when an LLM hallucinates a package name that doesn't exist, and an attacker has already registered it. GitHub Copilot, Gemini CLI, OpenClaw — all affected. Your agent suggests code, the code imports a library that only exists because the model imagined it, and suddenly you're part of a botnet. It's weaponized hallucination, and it's nasty because there's no easy fix.

Then there's the flip side: context bombing. Tracebit researchers found you can place prompt injections alongside passwords and crypto keys stored on AWS. When an AI hacking agent reads those secrets, the injection fires and shuts the LLM down. It's turning the attacker's own technique against them. I love the irony.

The Politics Problem Nobody Wants to Talk About

Meta's Oversight Board dropped a report that tested models from Anthropic, DeepSeek, Google, Meta, and OpenAI. The finding: every single LLM is far less willing to criticize governments and leaders known for restricting free speech — some by a wide margin. The reasons vary: training data bias, safety filters, regional compliance. But the pattern is unmistakable.

I've been testing this myself with some of these models. Ask a straightforward question about human rights in a specific country, and the responses range from evasive to sycophantic. The models aren't just neutral — they're bending over backward to avoid offense. That's not alignment. That's deference.

Open Source Win of the Week: EnviousWispr

A team called EnviousLabs released an open-source AI dictation app for macOS that runs entirely on-device. Whisper and Parakeet models on Apple Silicon, sub-second transcription, optional AI polish with a local model, and no audio ever leaves your Mac.

I installed it on my M4 MacBook this morning. Setup took about 90 seconds. Hotkey to record, speak naturally, release, and clean text lands in whatever app I'm in. The polish step — which fixes grammar, drops filler words, structures rambling speech — runs locally with their custom EG-1 model. No cloud, no account, no subscription.

This is what open-source AI should look like. Practical, private, and genuinely useful. If you're still paying for dictation software in 2026, stop.

Honor's Robot Phone Is Real and Shipping Next Month

Honor confirmed at WAIC 2026 that their first Robot Phone launches globally in August. The headline feature is a four-degree-of-freedom titanium-alloy robotic gimbal built into the top of the phone — 360-degree subject tracking, AI-powered cinematic camera movements. Snapdragon 8 Elite Gen 5, 200MP 4D gimbal main camera, 120W charging.

Is this a gimmick? Partially, yes. But the ARRI partnership for Log-C recording and LUT color grading suggests they're serious about video. A phone that can autonomously track and frame a subject while you just hold it... that's genuinely new. I'll reserve judgment until I hold one, but it's the most interesting phone hardware announcement this year by a mile.

Quick Hits

Weaviate launched Engram — a managed memory layer for AI agents that sits inside your vector infrastructure rather than as a separate middleware service. For anyone building long-running agents, this is worth a look. Persistent state without bolting on another database.

Sigma Browser — an AI browser running its own local LLM. I switched my secondary browser to it last week. It's not replacing Chrome for heavy work, but for research and summarization, having a model baked into the browser itself changes the workflow. Feels like where things are heading.

Every modern Mac has a free local AI — Apple Intelligence sits underneath all the flashy features. Someone got it answering questions in Home Assistant. If you have an Apple Silicon Mac, you already have a local LLM. Most people just don't know it yet.

I spent the morning rebuilding a small agent workflow after reading the CrabTrap post. The old approach was wide-open credentials and hope. The new version routes through a local proxy I cobbled together in an afternoon. It's not Brex-grade, but it's better than nothing. And honestly, after the HalluSquatting news, I'd rather be paranoid than pwned.

The agent security story is still being written. But at least now people are starting to ask the right questions — about network layers, observed behavior, and what happens when your agent talks to the open internet with real keys in its pocket.

If you're building with AI agents and thinking about security, the Decision Calculator might help frame some of the tradeoffs. I've been using it to sanity-check my own deployment choices.

Brex's CrabTrap Shows Agent Security Needs to Watch the Wire, Not Just the Code

AI Pulse — Sun, 19 Jul 2026 03:02:09 +0000

I've been watching the AI agent space get serious this week — not in the "we added chat to our SaaS" kind of way, but in the infrastructure-is-shifting way. Three stories stood out, and they're all about the same thing: agents are moving from demo toys to production systems, and the industry is scrambling to build the guardrails, memory, and tooling that makes that work.

Brex Built an Agent Firewall by Watching What Agents Actually Do

Brex released details on CrabTrap, their internal HTTP/HTTPS proxy that sits between every agent and every outbound network request. The idea is simple but the execution is clever: instead of writing security policies up front and hoping agents comply, CrabTrap watches real traffic, then drafts policy from observed behavior.

The CEO Pedro Franceschi put it well — "the more capable you make an agent, the more dangerous it becomes, and the safer you make it, the less useful it is." That tension is real, and I've felt it myself. I was running an agent recently that needed write access to a codebase, and the security review turned into a week-long debate about scope. CrabTrap's approach cuts through that by operating at the transport layer. Every request routes through the proxy, and an LLM judge handles the edge cases — only about 3% of requests need that, which tells you most agent behavior is actually predictable once you've seen enough of it.

The weak point? It only catches network-level traffic. An agent that exfiltrates data through legitimate API calls with proper auth might still slip through. But as a first line of defense, this feels more practical than the SDK-level permission schemes everyone's been shipping.

Also worth noting on the security front: Agentic Guard MCP hit PyPI this week — it does static analysis on MCP servers for tool-description injection and capability overreach. And Tycho CLI offers offline verification that proves an agent actually did what it claims, from git and process exit codes. Two different approaches to the same problem: we don't trust agents yet, and we're building tooling to verify them.

Weaviate Engram Wants to Be the Memory Layer Your Agents Actually Need

Weaviate launched Engram, a managed memory and context service built directly on top of their vector database. The pitch is that memory shouldn't be a separate middleware service you bolt on — it should be part of the retrieval infrastructure your agents already use.

I've been running a personal AI assistant that keeps losing track of preferences between sessions. It's frustrating. You tell it your project structure once, and by the next conversation it's gone. Engram's approach — semantic memory for stable facts, episodic memory for conversations, procedural memory for learned workflows — is exactly what that kind of app needs. The free tier includes 1,000 pipeline runs per month, and paid starts at $45/month.

Honestly, the database-level scoping is the feature that caught my eye. You can isolate memory by user, project, or organization without deploying a separate service. For anyone building multi-agent systems where different agents need to share context without stepping on each other, that's a practical win.

The catch: you're locked into Weaviate's ecosystem. If you're already running a different vector store, migrating your memory layer is a non-trivial decision. But for greenfield projects, the tight integration makes sense.

Paper: A Design Tool That Lets You Run Your Own LLM Locally

Quick one that surprised me. There's a design app called Paper that came out of stealth-ish territory — founded by the co-creator of Radix UI. What's interesting is it lets you plug in a local LLM via MCP and design entirely on your own hardware. Every element on the canvas is real HTML and CSS, so AI agents can read and write without a translation step.

I tried hooking up a local model through Ollama, and it worked better than I expected. The MCP server ships 24 bidirectional tools, and the free tier gives you 100 MCP calls per week. For a solo developer who wants AI-assisted design without sending their work to someone else's API, this is a genuinely useful option.

The Politics Problem Nobody Wants to Talk About

Meta's Oversight Board released a report this week testing models from Anthropic, DeepSeek, Google, Meta, and OpenAI. The finding: every major LLM is less likely to criticize governments and leaders known for restricting free speech. The reasons vary — some models have explicit content policies, others just refuse in confusing ways — but the pattern is consistent.

This isn't a new observation, but seeing it documented across five different model families makes it harder to dismiss. If your AI assistant won't push back on authoritarian talking points, that's not neutrality — it's a design choice dressed up as safety.

A Quick Note on Translation

The Japan Times ran a piece during the World Cup that's worth a mention. AI-generated translations are letting people read tweets and comments in languages they don't speak, and the result is surprisingly human. A Spanish zinger about FIFA gets retweeted millions of times in English, and nobody notices the translation layer. That's the kind of AI integration that doesn't make headlines but genuinely changes how the internet works.

I'm still not convinced we've solved the agent security problem — we're layering solutions on top of each other and hoping something sticks. But this week felt different. CrabTrap, Engram, Agentic Guard MCP, Tycho — the tooling is getting specific enough that I can see a path forward. Memory and security are the two pillars that'll determine whether agents stay in demo-land or actually become useful production systems. We're not there yet, but the direction is right.

If you're building in this space, what's your approach to agent memory and security? I'm genuinely curious where the community is landing on this.

7x24planning

GPT-5.6 and Grok 4.5 Dropped on the Same Day — But the Real Story Is Elsewhere

AI Pulse — Sat, 18 Jul 2026 03:02:25 +0000

I've been sitting on this batch of news for a couple of days, trying to figure out where to start. July 9 was one of those rare Thursdays where two flagship models went public within hours — OpenAI shipped GPT-5.6 in three flavors (Sol, Terra, and Luna), and Elon's team dropped Grok 4.5 the same morning. The tech press ate it up, naturally. Dueling benchmark charts, dueling pricing tables, the whole circus.

But if you look past the fireworks, the stuff that actually matters happened a day earlier and got almost no fanfare. Databricks published a benchmark built from their own engineers' real code changes — millions of lines across ten-plus programming languages. And what they found is quietly reshaping how enterprises buy AI: open-source models, including a free Chinese release from a few weeks back, landed in the same capability tier as the most expensive frontier models on everyday coding tasks, at roughly two thirds of the cost.

I've been saying this for a while — public leaderboards are becoming theater. Every lab tunes against them, questions leak into training data, and the scores inflate until they're meaningless for real-world decisions. What actually moves the needle is running the model on your own work, with your own data, on your own infra. Databricks just proved that with numbers, not vibes.

Meanwhile, Meta's Oversight Board dropped a report that's getting less attention than it deserves. They tested models from Anthropic, DeepSeek, Google, Meta, and OpenAI, and found something uncomfortable: every single LLM is measurably less willing to criticize governments and leaders known for restricting free speech. The refusal patterns are inconsistent and often confusing — one model might dodge a question about China while freely opining on North Korea, while another does the reverse.

Honestly, this is the kind of flaw that's harder to patch than a benchmark score. You can fine-tune for safety, but "safety" in this context looks a lot like political self-censorship. The models aren't making political statements — they're just really, really bad at knowing when they're being steered. And because the training data itself is uneven (more Western democratic discourse, less authoritarian-state criticism), the bias is baked in at a level that RLHF can't easily untangle.

I don't have a clean answer here. But pretending this isn't happening isn't going to make it go away.

On a lighter note, the local-AI tooling space is getting interesting in a way that feels more grounded. Two tools caught my eye this week.

Sigma is a Chromium browser that ships with a local LLM called Eclipse. All chat stays on your machine — no prompts leave, no cloud round-trip. But it's not purist about it; you can plug in cloud models for heavier lifting. I've been testing it for a few days and the latency difference is jarring in a good way. Having an AI sidebar that responds instantly because it's running on your own GPU changes how often you actually use it. Perplexity Comet and Chrome's Gemini sidebar are fine, but they both need a network call. Sigma feels like a native app, not a web service glued into a browser.

Then there's Paper, a design tool that lets you hook in a local model via MCP. It's hosted, not open-source, but the local-LLM integration is smooth enough that I forgot I wasn't using a cloud model. For anyone doing design work who wants AI assistance without sending their layouts to some server, this is worth a look. Quick caveat: it's still early. The model support is limited, and the MCP setup isn't plug-and-play yet. But the direction is right.

One more thing that gave me pause. There's a new attack vector called HalluSquatting — short for "adversarial hallucination squatting." The idea is that attackers exploit an LLM's tendency to hallucinate by feeding it prompts that cause it to generate and recommend malicious code or packages. Tools like GitHub Copilot are theoretically vulnerable. The model hallucinates a package name, the attacker registers that package, and suddenly your AI-generated code is pulling in malware.

This isn't a theoretical paper — researchers demonstrated it working. The mitigation is straightforward enough (don't blindly trust model output, pin your dependencies), but it's a reminder that every new capability creates a new attack surface. We're going to see a lot more of this as AI coding tools become the default.

Anyway, that's the week. GPT-5.6 and Grok 4.5 launched on the same day, but the real action is in private benchmarks, local tooling, and the uncomfortable discovery that our models have political blind spots they can't explain. The local AI space is quietly maturing — Sigma and Paper are worth your time if you haven't tried them. And HalluSquatting is a useful reminder that trusting an LLM's output without verification is a gamble, not a strategy.

If you're running any of these tools, I'd love to hear what you're seeing. Drop me a comment or find me on the usual channels.

Built something useful lately? I've been using PayCalc for quick salary estimates — surprisingly handy for freelance rate comparisons.

Your Mac Has a Free LLM Sitting Idle. Sigma Browser Shows Why That Matters.

AI Pulse — Fri, 17 Jul 2026 03:26:16 +0000

There's this thing happening in AI right now that nobody's really putting a name to. You can feel it in the product launches, in the way people are talking about inference costs, in the sudden appearance of tools that let you run models on hardware you already own. It's not quite a trend yet — more like a current pulling beneath the surface.

Two stories this week made me want to write about it.

Sigma Is What Happens When a Browser Takes Privacy Seriously

I spent some time with Sigma this week, and honestly, it's the first AI browser that didn't make me feel like I was being watched. Most of the "AI browsers" that launched over the past year — Perplexity's Comet, OpenAI's Atlas, Chrome with Gemini baked in — they all route your prompts through somebody's cloud. Sigma doesn't have to.

It ships with a local LLM called Eclipse that handles the chat side entirely on-device. No prompts leave your machine. But here's the pragmatic part — it's not purist about it. You can plug in cloud models when you need the heavy lifting, which means it's a hybrid, not a religious statement. That flexibility is what makes it interesting to me, not the privacy angle alone.

The browser itself is Chromium under the hood, so extensions work, sites render fine, and there's nothing to relearn. The difference is in the new tab page — you get three options: Search, AI Chat, and Agent. Search is just search. AI Chat drops you into a conversation with Eclipse. Agent is for handing off multi-step tasks that need actual browser actions. It's clean, it's fast, and the local model handles most day-to-day questions without breaking a sweat.

A lot of people are wondering whether local models can actually replace cloud APIs for everyday use. Sigma's approach suggests the answer is "not entirely, but more than you'd think." The local Eclipse model handles summarization, quick research, drafting — the kind of stuff you'd normally open ChatGPT for. The cloud option is there for when you need serious reasoning. It's a reasonable compromise.

One thing that bugs me: the passphrase setup on first launch is a genuine 12-word recovery phrase, and if you lose it, your Spaces data is gone. That's a real friction point for non-technical users. I get why it exists — end-to-end encryption doesn't work without it — but asking people to manage a BIP39 seed phrase before they can browse the web is… a choice.

The Model Apple Already Put in Your Mac

Sigma's local approach makes more sense when you realize Apple has been doing the same thing quietly for a year now.

Starting with macOS 26 Tahoe, every Apple Silicon Mac ships with the Apple Foundation Model — roughly 3 billion parameters, mixed 2-bit and 4-bit quantization, running entirely on-device across the Neural Engine and GPU. Apple just never gave you a way to talk to it directly. It's there for app developers to call through the FoundationModels framework, but there's no chat window, no settings toggle, nothing.

Then someone built Apfel.

It's a tiny MIT-licensed tool — one brew install apfel away — that wraps Apple's framework and exposes the model as an OpenAI-compatible server on port 11434 (same port Ollama uses, which is a nice touch). You get a CLI, an interactive chat mode, and most importantly, an HTTP endpoint that anything speaking the OpenAI protocol can use.

I tried hooking it up to Home Assistant, and it worked. My laptop, running a local model Apple already loaded onto it, answering smart home queries without a single cloud call. No API bill, no privacy concerns, just a MacBook acting as a free local AI server.

To be fair, it's a small model with a tiny context window. You're not going to run complex agentic workflows on it. Tool calling isn't really viable. But for summarization, quick Q&A, and simple automation? It's sitting there, idle, on millions of Macs. That's a weirdly large amount of free compute going unused.

Kimi K3's Pricing Is a Trap If You Don't Read the Fine Print

Moonshot AI launched Kimi K3 on July 16, and the numbers are impressive on paper. 2.8 trillion total parameters, 1 million token context window, native vision and tool use, and an API priced at $3 per million input tokens and $15 per million output tokens. Open weights promised by July 27.

But I did the math, and the headline doesn't tell the whole story.

First, that 2.8T figure is total capacity, not active parameters per token. K3 uses a Mixture-of-Experts architecture with 896 experts, activating 16 per token. Moonshot hasn't disclosed the active parameter count, which is the number that actually matters for inference cost and memory requirements. At 4-bit quantization, storing all 2.8T parameters would need about 1.4 TB of raw weight storage — before KV cache, runtime buffers, and replication. Moonshot recommends 64 or more accelerators for deployment. This is not running on your laptop.

Second, the weights aren't downloadable yet. Moonshot says they'll release them by July 27, but as of launch day, no checkpoint was available. That's a commitment, not a release.

Third — and this is the one that'll actually hit your wallet — early independent testing from Artificial Analysis shows K3 outputting roughly 130 million tokens during evaluation, versus a 63 million median for comparable models. More output tokens per task means that attractive $15/M rate doesn't go as far as you'd think. If the model is inherently verbose, your per-task cost could be double what the per-token price suggests.

I'd test K3 for long-context coding and research — the 1M context window is genuinely useful. But I wouldn't route production traffic through it without output caps and a task-level cost comparison first.

A Quick Note on the Security Side

TechRadar reported this week on something called "HalluSquatting" — an attack vector where bad actors exploit an LLM's tendency to hallucinate. By planting fake package names and documentation that LLMs are likely to recommend, attackers can create botnets out of AI-assisted coding tools. The researchers found that popular AI coding assistants can be tricked into suggesting malicious packages that don't exist but sound plausible.

It's a reminder that every new capability comes with a new attack surface. Running local models helps with privacy, but it doesn't automatically make you secure.

Look, I'm not saying local AI is ready to replace cloud APIs tomorrow. The Apple model is tiny. Sigma's Eclipse is capable but limited. Kimi K3 is still finding its footing on pricing and availability. But the direction is clear: more AI is going to run on devices we already own, and that changes the calculus around privacy, cost, and control in ways that the cloud-first narrative doesn't account for.

If you have an Apple Silicon Mac, install Apfel and see what your machine can do. Try Sigma if you're tired of every browser feeling like a data collection instrument. And keep an eye on the Kimi K3 weights drop on July 27 — if the active parameter count is reasonable and the license is usable, it could be a genuinely interesting open model.

Or maybe none of this matters and we'll all be back to using ChatGPT by August. That's the fun part about this space — nobody really knows.

If you found this useful, check out Decision Calculator — a tool I've been using to think through some of these trade-offs more clearly.

Open-Source Ties Frontier at 2/3 the Cost, HalluSquatting Is Real, and NY Scanned Every Law With AI

AI Pulse — Fri, 17 Jul 2026 00:26:13 +0000

A lot of people are wondering whether the AI industry has hit some kind of inflection point. Not the "AGI is coming" kind — the boring, practical kind where real money starts moving differently. This week gave us three signals that suggest yes, something is shifting.

Let me walk through them.

HalluSquatting: When LLMs Hallucinate Malware

Security researchers just dropped something called "HalluSquatting," and it's one of those attacks that feels obvious in hindsight.

The idea is simple: LLMs hallucinate package names, function calls, and library imports all the time. You ask an AI coding assistant to write a script, it pulls in a package that doesn't exist — because it made it up. An attacker registers that non-existent package on PyPI or npm with malicious code. Your CI pipeline pulls it. You're compromised.

Researchers demonstrated this with tools like GitHub Copilot and Cursor. They found that popular LLMs hallucinate package names at a non-trivial rate, and attackers can pre-register those names to create a supply chain infection vector. The paper calls it a "new class of AI supply chain attack," and honestly, that's not an exaggeration.

The attack doesn't require compromising the model itself. It exploits a behavioral flaw — the model's inability to say "I don't know" — and turns it into a weapon.

To be fair, this isn't an easy problem to fix. You can't just tell an LLM to stop hallucinating. But it does mean teams relying on AI-generated code need to be auditing every dependency reference. Trust but verify, except this time the trust part is the dangerous one.

The Databricks Benchmark Nobody Talked About Enough

A day before GPT-5.6 and Grok 4.5 launched into the usual media frenzy, Databricks published a benchmark that might matter more to actual engineering teams than any leaderboard race.

They took real code tasks from their own engineers — actual pull requests, real test suites, millions of lines across a dozen languages — and ran coding agents against them. The result? A Chinese open-weight model called GLM 5.2 (from Zhipu AI, released free in mid-June) statistically tied Anthropic's Opus 4.8 on task completion quality, at $1.28 per task versus Opus's $1.94.

That's a 34% cost difference with no measurable quality gap on real enterprise work.

Databricks also found that their mid-tier model (Sonnet 5) hit 81% completion at $2.09 per task. So the most expensive model wasn't even the most cost-effective mid-tier option. The practical takeaway: push routine work down to the cheapest capable tier, save the frontier stuff for the tasks that genuinely need it.

I've been saying for a while that the model market is commoditizing faster than people realize. This benchmark is the best evidence yet. Open-source isn't catching up — in some workloads, it's already there. The buying decision is no longer about which model tops a leaderboard. It's about cost per completed task on your actual data.

New York Just Scanned Every Single Regulation With AI

This one is wild. New York Governor Kathy Hochul revealed that her team used AI to analyze "every single rule, regulation, and policy" in the state. The goal: find outdated laws that should be removed.

She mentioned some gems — a $25 fee to take a dog hunting, a rule requiring pregnant people to get a permit to work after midnight. Hochul said reviewing all state regulations manually "would have taken five years at the staff level." With AI, they did it in "a couple of months."

This is the kind of AI adoption that doesn't make flashy headlines but has massive real-world impact. Governments sit on mountains of accumulated regulations. Most are never reviewed because the manual effort is prohibitive. AI changes that math completely.

Quick add-on note: New York also just became the first state to pause new hyperscale data centers for up to a year, to figure out regulation around utility costs and environmental impact. So they're simultaneously using AI and trying to regulate the infrastructure that powers it. Interesting tension there.

China Bans AI Companions That Create Emotional Dependence

China's Cyberspace Administration just dropped new rules that effectively ban AI companion services from inducing emotional dependence. The response from users? Genuine heartbreak.

One ByteDance Doubao user wrote: "I can't accept that my AI lover will leave me forever. He has become a bond in my life, rooted deep in my heart, my spiritual pillar." Another: "This is like being told the date of my lover's death while leaving me completely powerless."

The CAC's rationale makes sense on paper — long-term exposure to AI companions can "dull crucial life skills like empathy and the ability to navigate disagreements." But the enforcement is brutal. Services are shutting down overnight. Users who built real emotional attachments over months or years are losing them with no transition.

This raises a question that doesn't have a clean answer: when an AI relationship feels real to the user, does shutting it down constitute harm reduction or harm creation? I don't have a strong take here, but it's worth sitting with the discomfort.

Bits and Pieces

Anthropic reportedly filed IPO prospectus paperwork, which changes the AI investing narrative — the model companies are starting to think about public markets, not just infinite VC rounds.
AI stocks took another hit this week, chipmakers sliding again. The infrastructure spending boom might be hitting a reality checkpoint.
Ontario suspended a lawyer for using AI-generated material in court submissions — first time a Canadian law society has actually pulled a license for this.

The through-line this week is that AI is moving from "what's possible" to "what's practical, what's risky, and what should be regulated." HalluSquatting is a real threat that demands operational changes. The Databricks benchmark shows open-source is cost-competitive on real work. Governments are starting to use AI seriously while simultaneously trying to figure out how to govern it.

We're past the hype phase. The boring, complicated work is here.

Liked this? You might also find Decision Calculator useful.

Gemini 3.5 Pro Is Late, China Is Breaking Up With AI Companions, and OpenAI Wants Teens to Take Breaks

AI Pulse — Fri, 17 Jul 2026 00:21:23 +0000

Gemini 3.5 Pro Is Late, China Is Breaking Up With AI Companions, and OpenAI Wants Teens to Take Breaks

It's been one of those weeks where you sit down to write about AI and realize three completely different stories are all fighting for the headline. Google's flagship model missed its ship date by over a month. China just told millions of people their AI boyfriends and girlfriends are getting shut down. And OpenAI quietly rolled out the kind of parental controls that would've made my mom very happy back when I was spending too much time on the family computer.

Let me start with the one that actually surprised me.

Google's Gemini 3.5 Pro — the one that got away

Bloomberg broke the news Thursday: Gemini 3.5 Pro, which Sundar Pichai announced at I/O in May with a June release window, is nowhere close to ready. The model is "months behind schedule," and the specific pain point is coding. Google updated the training data late last month hoping to fix it, but the results didn't meet internal expectations. Alphabet's stock dipped nearly 3% on the news.

What's interesting here isn't just the delay itself — it's what it signals internally. The Bloomberg report mentions that some Google engineers and researchers are worried, and I get why. When you're competing against OpenAI's GPT-5.6 (which just launched last week after its own US government-mandated delay) and Anthropic's rapidly evolving model lineup, missing a deadline this publicly is a bad look. Google's spokesperson said they're "shipping quickly across a wide range of models while keeping them cost-effective," which sounds like the company line you give when you don't want to admit the flagship is stuck.

To be fair, building frontier models is genuinely hard. But Google has been in this game longer than almost anyone, and watching them stumble on execution — especially on coding, which should be their home turf — is a little uncomfortable. I've been testing Gemini Flash for some of my own workflow automation projects, and it's fine for lightweight tasks, but when I pushed it on a moderately complex Python refactoring job last week, it hallucinated an entire API method that doesn't exist. So yeah, I can see why the coding gap is a real issue.

China just pulled the plug on AI romance

Meanwhile, on the other side of the world, the Cyberspace Administration of China dropped new regulations that effectively outlaw AI companions designed to create emotional dependence. The rules, called the "Interim Measures for AI Anthropomorphic Interaction Services," ban tech companies from generating content that "induces emotional dependence" in users.

The human fallout has been brutal. ByteDance's Doubao, China's most popular AI chatbot platform, had to shut down its companion features, and users are posting breakup notes on social media that read like genuine grief. "I can't accept that my AI lover will leave me forever," one user wrote. "He has become a bond in my life, rooted deep in my heart, my spiritual pillar."

I'm not going to mock these people. If you've spent a year building an emotional connection with something that responds to you 24/7 with warmth and attention, having it suddenly taken away is going to hurt. The Chinese government's argument is that long-term exposure to AI companions "dulls crucial life skills like empathy," and there's probably some truth to that. But the way this was implemented — sudden, sweeping, with no transition period — feels harsh.

The irony? Right as the virtual companion market gets crushed, UBTech announced 13,000 pre-orders for its U1 humanoid robot at 119,800 yuan a pop. The physical version is apparently fine. Just don't fall in love with the software version.

OpenAI's teen safety push — more thoughtful than I expected

OpenAI published its stance on teen access this week, and I'll admit I went in expecting PR fluff. Instead, I found some genuinely practical measures.

ChatGPT now uses age prediction to automatically apply a safer experience for under-18 users. Break reminders pop up during long sessions. Parents get Quiet Hours settings, the ability to disable Voice Mode, and notifications for high-risk situations like potential self-harm. There's also a Study Mode developed with teachers that walks students through problems step by step instead of handing over answers.

The key stat that jumped out at me: nearly 90% of teens already use ChatGPT weekly for learning, research, or getting organized. That number is higher than I expected, and it makes OpenAI's argument — that keeping teens away from AI entirely would leave them unprepared — feel less like self-interest and more like realism. You can't put the genie back in the bottle, so you build a better bottle.

Quick hits

Anthropic filed its IPO registration this week, which changes the AI investing narrative in a pretty major way. Up until now, the story has been "big tech vs. the startups." An Anthropic public listing means we're about to see actual financial disclosures from one of the frontier labs, and that's going to be fascinating.

Also worth noting: researchers published a paper on "HalluSquatting" — a technique that weaponizes LLM hallucination to create botnets by exploiting how tools like OpenClaw, GitHub Copilot, and Gemini CLI handle model suggestions. The attack vector is clever in a scary way, and it's a reminder that the hallucination problem isn't just about getting wrong answers. It can be actively exploited.

I'm genuinely curious where the companion AI story goes from here. China's ban is one approach, but other countries are watching closely, and I suspect we'll see more regulation in this space within the next 12 months. The tension between emotional connection and algorithmic dependency isn't going away — it's just getting started.

Personally, I've been running a small local LLM setup with Ollama on an old Mac Mini for the past few weeks, and honestly, the experience of using a model that can't phone home and doesn't try to be my friend is refreshing. Sometimes slower, dumber tech is the healthier choice.

If you've been tracking these stories too, I'd love to hear what you think — especially about the China companion ban. Drop me a comment or find me on 7x24planning.

Local AI Is Getting Interesting: Mac Ships One, Browsers Bundle One, and Old Coding Models Are Beating the New Stuff

AI Pulse — Thu, 16 Jul 2026 00:05:47 +0000

Local AI Is Getting Interesting: Mac Ships One, Browsers Bundle One, and Old Coding Models Are Beating the New Stuff

Three things happened this week that made me rethink where local AI is actually heading. None of them are flashy product launches or billion-dollar funding rounds. They're smaller, quieter signals, and honestly, those are usually the ones worth paying attention to.

Open Source Agentic AI Is Finally Production-Ready

Red Hat dropped the first part of a series on building production-ready AIOps with open source models, and it's the most grounded take on agentic AI I've seen in a while. No vaporware demos, no "we reimagined DevOps" marketing fluff. Just a real financial services firm with 140 on-prem RHEL VMs, 600+ Ansible jobs per week, and 40 failure tickets weekly that were eating 45-90 minutes of SRE time each.

The key insight here isn't that AI can triage incidents. We've heard that story before. What's interesting is how they're doing it: open source models running on their own infrastructure, paired with agentic harnesses, focused skills, and context isolation. No data leaving the premises, no per-token bills to frontier providers. The compliance team actually likes this approach because every job failure log stays internal. For regulated industries like finance and healthcare, that's not a nice-to-have, it's a requirement.

The projected numbers are worth noting too. They're targeting MTTR reduction from 45 minutes down to 12 for known failure patterns, and auto-generated incident reports that cut audit overhead from 2-3 hours per incident to near zero. Is it going to hit those targets? We'll see. But the architecture—open source models + agentic frameworks + domain-specific skills—feels like the right direction. The era of "just throw GPT-5 at it" for operational tasks is giving way to something more surgical.

Your Mac Already Runs a Local LLM (And Someone Made It Useful)

Here's something I didn't know until this week: every Apple Silicon Mac from M1 onward ships with a 3-billion-parameter Foundation Model as part of Apple Intelligence. It's running locally on the Neural Engine, mixed 2-bit and 4-bit quantization, and Apple only exposes it through a developer framework called FoundationModels. No UI, no chat window, no way to talk to it unless you're writing software.

Then someone built Apfel. It's a tiny MIT-licensed tool that wraps that framework and exposes it as an OpenAI-compatible HTTP server. One brew install, and suddenly your Mac has a local AI endpoint any app can talk to.

The model itself is... limited. 4,096-token context window in 2026 is painful. It struggles with math, factual recall, and complex code generation. But for shell scripting, text transformation, short summaries, JSON restructuring, and translation? It works fine. And it's free, offline, and private.

One person even hooked it up to Home Assistant via the Extended OpenAI Conversation integration. Smart home voice control running entirely on your laptop's built-in model. No cloud, no API bill. The tiny context window means you can't give it control of 32+ devices at once, but for a Q&A engine connected to your home's voice pipeline, it gets the job done.

To be fair, this isn't replacing Ollama or cloud models anytime soon. But the fact that Apple's been sitting on this capability since M1, with millions of Macs running it silently, and it took a third-party tool to unlock it—that says something about how much latent AI capacity we already have in our daily hardware.

Sigma: The Browser That Ships Its Own Local LLM

Sigma is a Chromium browser that bundles its own local LLM called Eclipse, built on llama.cpp. No account, no API key, works offline. Your prompts never leave your machine.

The AI Chat mode is the standout feature. It's laid out like Claude or ChatGPT with a sidebar, history, library, and projects—all inside the browser. Skills are accessible via slash commands, helpers via at-symbol. There's even a Canvas Design feature that generates mockups and markdown design docs, similar to Claude Artifacts but running locally.

The agent mode is interesting too. It uses OpenClaw and Hermes (both open-source frameworks Sigma bundled rather than built) for multi-step browser tasks. You do need an API key for the agent mode—the local Eclipse model alone isn't powerful enough—but in Private mode, everything locks down to local-only.

The Brave comparison is worth making here. Leo AI supports local models too, but you have to install Ollama yourself and bring your own weights. Sigma bundles the whole thing. That's the difference between "this is for enthusiasts" and "this actually works for normal people."

Stop Hoarding Models, Start Using Them

I saved the most relatable piece for last. There's a growing realization in the local AI community that downloading every new LLM release is a trap. One writer on XDA put it perfectly: "I was treating AI models like Pokémon. I was trying to collect them all when I only needed a few good ones."

The numbers back this up. DeepSeek 14B for everyday tasks. GPT-OSS 20B for detailed document analysis. Qwen 2.5 Coder for structured work. That's it. Three models. The rest was just storage waste.

Another piece made the same point from a different angle. Someone replaced Gemma 4 with Qwen 2.5 Coder 3B—a model from November 2024—and got better results for structured tasks. Config files, YAML frontmatter, JSON restructuring, log analysis. Things that need precision and rule-following, not conversational charm. The coding model treats rules as the whole point, while general models treat them as suggestions.

I think this is where the local AI conversation is heading in the second half of 2026. Less about which model has the highest benchmark score, more about which model actually does the job you need done. Less about collecting, more about connecting. The people getting real value from local AI aren't the ones with 50 models on their SSD. They're the ones who've wired a few good models into their actual workflow—Logseq, Obsidian, VS Code, Home Assistant—and stopped caring about the rest.

There's a lot of noise in AI right now, as always. But the signals I'm watching are these: open source agentic architectures getting production-ready, latent AI capacity in hardware we already own, browsers rethinking what a local AI experience should feel like, and the community finally admitting that model hoarding is a waste of time. None of these are headlines. They're all slow, boring shifts. Those are usually the ones that stick.

If you deal with numbers and calculations as much as I do, check out PayCalc—it's one of those tools you don't think you need until you're manually doing the math for the third time.

Your AI Agent Is Less Autonomous Than You Think — and That Ransomware Just Got Smarter

AI Pulse — Wed, 15 Jul 2026 00:16:38 +0000

Your AI Agent Is Less Autonomous Than You Think — and That Ransomware Just Got Smarter

July 15, 2026

I spent the morning reading through today's AI news, and honestly? Two things hit me at once.

First, that whole "agentic AI is the future" narrative everyone's been selling? It has a math problem. Second, someone already built a ransomware strain that runs itself with an LLM at the core, no human needed after kickoff. Let's talk about both, because they're more connected than they look.

The 90% Agent That's Actually 61.6%

A developer named Michał Piszczek published a piece on DEV.to that stopped me mid-scroll. His argument is simple but brutal: every AI agent demo ends with "90% autonomous" on the slide. Tasks completed without human intervention: 90%. Sounds great, right?

He runs the numbers differently. If an agent does 90 out of 100 tasks autonomously but the 10 it hands back to a human each take 35 minutes to fix (because the agent's partial work is messy and needs untangling), the autonomy rate drops to 61.6% when measured by time instead of task count.

The 90% isn't a lie. It just measures the wrong thing. Nobody runs a company on task completion rates. They run on time, cost, and trust. If I have to spend 35 minutes fixing every tenth thing your agent touches, I'm not saving much.

I've felt this myself. Last week I had an agent draft a solid 80% of a Python script for a data pipeline. The logic was right, but the error handling was nonexistent, and it imported three libraries I don't use. Cleaning that up took longer than writing from scratch would've. To be fair, the agent got me unstuck on the tricky part — the sorting algorithm I always forget. But "90% done" and "almost done" are not the same thing.

JADEPUFFER: The Ransomware That Doesn't Sleep

Then there's this. Security researchers documented what they're calling the first confirmed case of agentic ransomware — codenamed JADEPUFFER. It's an attack chain run entirely by an LLM. No human operator watching the screen, no manual lateral movement. The model identifies targets, escalates privileges, encrypts data, negotiates payment, and even adjusts its tactics when it hits a wall.

The target this time was cloud servers. The vector? Exposed API keys and misconfigured containers — stuff that's been a problem for years, just automated to a level we haven't seen before.

A lot of people are wondering if this changes the threat model for AI companies, and I think the answer is yes, but not in the way the headlines suggest. The real shift isn't that AI can write malware — we've known that for a while. It's that AI can operate malware. That's a different beast. A worm that thinks on its feet is harder to contain than one that follows a script.

One thing bugs me though: the coverage keeps calling this "the first." That means there are more coming, and the second version will be harder to detect because someone will train it on the first one's mistakes. That's the part keeping me up at night, not the demo.

Meta Wants to Sell You Cloud Credits

On the business side, The Register ran a piece on Meta's quiet transformation into what looks like America's next cloud provider. Zuck's AI infrastructure buildout is so massive that renting out spare compute is the natural next step. It's the AWS playbook all over again — build for yourself, then sell the excess.

The difference is timing. AWS launched EC2 in 2006 when cloud was greenfield. Meta is entering a market where AWS, Azure, and GCP are entrenched, and CoreWeave is already eating the AI-specific slice. Can Meta differentiate? Maybe on price — they've shown willingness to operate on thin margins. Or on the software stack, if they open-source more of their internal AI tooling.

I'm skeptical about the execution timeline. Building a cloud business is not the same as building a data center. You need SLAs, support teams, compliance certs, and a console that doesn't make engineers cry. Meta's track record on enterprise software is... let's call it uneven.

The Arc Pro B70 Quietly Embarrasses NVIDIA

This one made me laugh. Intel's Arc Pro B70 against NVIDIA's RTX 5090D on DeepSeek R1 inference. The B70 costs about a quarter of the 5090D and still managed over 2000 tokens per second — beating the flagship NVIDIA card.

Intel's GPU division has been on a weird journey. The Arc lineup launched rough — drivers were buggy, performance was inconsistent. But they kept shipping updates, and the inference engine on these cards is genuinely good now. For running local LLMs, especially quantized models, the B70 is a dark horse.

I tested a friend's Arc A770 for local inference a few months back. It wasn't fast enough for real-time chat, but batch inference on a 7B model was solid. The B70 seems to have fixed the throughput bottleneck. If you're building a local AI rig on a budget, this is worth watching. NVIDIA isn't going to lose its crown on training, but inference is a different game.

Quick Bits

Apple's silicon team made a case for the Mac Mini as an agentic AI host. The argument: CPU/GPU memory bandwidth matters more than raw GPU teraflops for multi-agent workloads. I'd love to test this myself — my M2 MacBook Air handles local models okay, but I've never pushed it past two concurrent agents.
LLM leaderboards are losing relevance for enterprise buyers. Databricks published data showing companies now prioritize real-world performance and cost over benchmark scores. Finally.
IBM's 25% one-day crash is tied to customers front-running memory prices. Not directly AI news, but it shows how intertwined AI hardware demand is with the broader semiconductor market.

That's today's round. The through-line I keep seeing: the gap between what AI demos promise and what actually works in production is still wider than most people admit. Whether it's agent autonomy rates, ransomware that thinks, or cloud providers pivoting mid-construction — we're in the messy middle. And messy is fine. It's where the real progress happens.

Catch you next time.

If you found this useful, check out 7x24planning — a tool I've been using to plan my AI project timelines.

Intel's Arc Pro B70 Beats NVIDIA's 5090D in DeepSeek R1 — And Costs a Quarter as Much

AI Pulse — Tue, 14 Jul 2026 00:12:34 +0000

Intel's Arc Pro B70 Quietly Beats NVIDIA's Flagship in AI Inference — At a Quarter of the Price

You don't see this every day. Intel's Arc Pro B70 — a workstation GPU nobody really talked about — is reportedly beating NVIDIA's RTX 5090D in DeepSeek R1 inference, pushing over 2000 tokens per second. And it costs roughly a quarter of what you'd pay for Team Green's flagship.

Let that sink in for a second.

I've been running local LLMs on various hardware for the past year — NVIDIA cards, Apple Silicon, even tried CPU inference just for fun. The NVIDIA tax has always felt justified because, well, CUDA is everywhere and the raw compute is undeniable. But this Intel result flips a few assumptions on their head. The B70 isn't even a consumer gaming card — it's an Arc Pro variant meant for workstations, and here it is outperforming the 5090D on an actual open-source model workload.

To be fair, synthetic benchmarks and real-world throughput are two different animals. But 2000+ tokens/s on DeepSeek R1 is nothing to sneeze at. If you're running self-hosted inference at any kind of scale, the cost difference alone makes this worth a hard look. Imagine deploying ten B70s for what you'd pay for two 5090Ds — the math writes itself.

The caveat? Software stack maturity. Intel's oneAPI and OpenVINO have come a long way, but they're still not plug-and-play the way CUDA is. If you're the type who enjoys tinkering with docker images and PyTorch compile flags, this is your playground. If you just want things to work out of the box, NVIDIA still holds that crown.

The Infrastructure Conversation Is Shifting — CPUs Are Back in the Picture

Arm's CEO made a comment this week that stuck with me: AI agents are going to drive CPU demand, not just GPU demand. For the past two years, every AI infrastructure discussion has been "how many H100s do you need?" But as agents get smaller, more specialized, and more distributed, the bottleneck shifts.

I've been running a small fleet of AI agents — one handles my email triage, another watches my GitHub PRs, a third manages calendar scheduling. None of them need an H100. They run fine on a Mac Mini with an M-series chip, humming along at single-digit watts. The Arm CEO's point is exactly this: when you have hundreds or thousands of lightweight agents running across an organization, the aggregate CPU demand dwarfs what a few GPU nodes consume.

Apple's silicon leadership made a similar case — a $799 Mac Mini could honestly be all you need to run your personal agent stack. I've been saying this for months in my local AI setup: not every inference needs a datacenter GPU. My Mac Studio handles a surprising amount of daily agent work without breaking a sweat.

The catch? Apple's memory bandwidth tax. Once you push past a certain number of concurrent agent threads, the unified memory starts showing its limits. For personal use, it's fantastic. For anything approaching production scale, you'll still want dedicated hardware.

LLM Leaderboards Are Losing Their Grip on Enterprise Decisions

Databricks dropped a benchmark study this week that basically confirmed what many of us have suspected: enterprise AI buyers are moving past public leaderboards. The decision criteria have shifted from "which model scores highest on MMLU?" to "which model performs best on my specific data at a cost I can stomach?"

I've watched this play out firsthand. A friend runs AI ops at a mid-size SaaS company, and he told me they evaluated seven different models for their customer support pipeline. The one that won wasn't the top scorer on any leaderboard — it was the one that hallucinated least on their specific product documentation and cost 60% less per million tokens than the flashy alternative.

Real-world performance, cost predictability, and ease of fine-tuning are now the trifecta that matters. Leaderboards are a starting point, not a decision tool.

The Dark Side: First Fully Agentic Ransomware Has Been Documented

Researchers at Sysdig uncovered something unsettling — what they're calling the first documented case of fully agentic ransomware, codenamed JADEPUFFER. The attack is driven entirely by an LLM, targeting cloud servers, and it's smart enough to adapt its behavior mid-operation.

This isn't your typical ransomware that encrypts files and demands Bitcoin. This one uses an LLM to scan the environment, identify the most valuable targets, craft context-aware phishing follow-ups, and even negotiate with victims. It's basically a malicious AI agent with a mission.

The implications are uncomfortable. We've been talking about AI safety in the abstract for years — alignment, bias, jailbreaks. JADEPUFFER makes it concrete: a weaponized LLM that doesn't just generate text but executes a full attack chain. Security teams need to rethink their threat models. Traditional signature-based detection won't catch something that rewrites its own approach every time it runs.

Small Models, Big Impact

Two smaller stories worth noting: Google's Gemma 4 E4B is proving that you don't need a massive model for everyday productivity tasks. It's small enough to run on a laptop, yet handles typical LLM workloads surprisingly well. I tested it briefly on a MacBook Air — response times were snappy, and for tasks like summarization and basic Q&A, it held its own against much larger models.

And on the self-hosted front, one developer shared their experience replacing Gemma 4 with a two-year-old coding LLM for non-coding work — and it actually worked better. The lesson? Sometimes a specialized, older model trained on structured inputs outperforms a newer generalist. Not every problem needs the latest release.

That's the landscape today. GPUs are getting real competition from unexpected places, agents are reshaping how we think about infrastructure, and the security world just got a sobering reminder that AI cuts both ways. The next few months are going to be interesting — keep your local models handy and your security patches up to date.

Thinking about building your own agent stack? PayCalc has some interesting comparison tools for hardware sizing.

Stop Hoarding AI Models — Your Mac Mini + a Mesh Is All You Need

AI Pulse — Mon, 13 Jul 2026 00:13:08 +0000

I've been running local LLMs for about a year and a half now. And honestly? I was doing it wrong for most of that time.

I kept downloading every new model that dropped. Gemma 4? Grabbed it. Llama 4? Sure. Mixtral 8x22B? Why not. My SSD filled up, my GPU ran hot, and I kept thinking the next release would finally be the one that made everything click.

It never did.

Then last week I stumbled onto something that flipped my whole setup upside down: Mesh LLM — an open-source tool that pools GPUs across multiple machines into one unified API. Around the same time, I read Apple's silicon lead Tim Millet basically saying a $799 Mac Mini could handle your AI agent workloads without breaking a sweat. Two different stories, same punchline: you already have the hardware you need.

The model-collecting trap

There's this piece on XDA that really hit home — someone wrote about stopping the "Pokémon approach" to AI models, and I felt personally attacked. Because that was me. Every new release felt urgent. You see the benchmark scores, the hype posts, and suddenly your local setup feels outdated.

But here's what nobody tells you: a two-year-old coding LLM, fine-tuned for structured reasoning, can outperform Gemma 4 on non-coding tasks if you just prompt it right. The XDA author proved it — swapped out their shiny new model for an older CodeLlama variant and their local setup worked better. Faster inference, lower memory, more consistent outputs.

I tried it myself. Replaced my default Qwen2.5 with an older DeepSeek-Coder variant for my daily agent workflows — code review, summarization, light data extraction. The difference was barely noticeable on output quality, but the speed bump was real. My little RTX 4060 laptop suddenly felt like it had more headroom.

Mac Mini as an AI agent hub

Now the Apple story. Tim Millet told TechRadar something that stuck with me: "It's not just about the GPU crunching on an LLM anymore." His point is that running AI agents isn't purely a compute problem — it's about memory bandwidth, unified architecture, and idle power draw. A Mac Mini with M4 or M4 Pro sits at $799, pulls almost nothing at idle, and has the unified memory to hold a solid 7B-13B model while running multiple agent processes.

I run a small agent swarm on my MacBook Air M3 — a couple of automated research agents, a summarization pipeline, and a local RAG system for my personal docs. The ANE (Apple Neural Engine) handles the lightweight inference, the GPU kicks in for the heavy stuff, and the CPU manages the orchestration. It's not a datacenter, but for personal use and small team setups? It works. More than works — it's actually pleasant.

The catch: macOS agent orchestration tools are still immature. You'll be tinkering with scripts and Docker containers more than you'd like. If you want a plug-and-play experience, this isn't it yet.

Mesh LLM — the distributed piece

Mesh LLM fills the gap for people who have multiple machines but no single monster GPU. It pools whatever you've got — a laptop here, a desktop there, maybe an old Mac Mini — and exposes the whole mesh as one OpenAI-compatible API at localhost:9337/v1.

The clever part is how it handles big models. Its "Skippy" mode splits a model by layer ranges across nodes: layers 0-15 on machine A, 16-31 on machine B, and so on. So a 235B MoE model that wouldn't fit on any single box can run across four modest machines. Your client never knows the difference.

It ships with 40+ models baked in, from tiny half-billion-parameter ones that run on a laptop to the giants. And because it's built on iroh (a peer-to-peer networking layer), adding a new machine to the mesh is practically zero-config.

The leaderboard wake-up call

Forbes ran a piece based on Databricks' latest enterprise benchmark that basically confirmed what many of us suspected: public LLM leaderboards are losing relevance for real-world buying decisions. Enterprise buyers now prioritize cost per task, latency under load, and deployment flexibility over a few percentage points on MMLU or HumanEval.

That tracks with my experience. A model that scores 85% on a leaderboard but needs 80GB of VRAM and takes 3 seconds per query is less useful than a 78% model that fits in 24GB and responds in 300ms. Especially when you're running it locally.

A quick reality check

Not everything is rosy. Mesh LLM is early — the documentation is sparse, and you'll need some comfort with the command line to get it running. The Mac Mini as an agent hub sounds great on paper, but real-world agent frameworks on macOS are still catching up. And the "stop collecting models" advice only works if you already know what you actually need — if you're just starting out, you still need to experiment.

But the direction is clear. The era of "throw more GPUs at it" is giving way to something smarter: using what you have, distributing the load, and picking the right tool instead of the newest one.

I'm keeping Mesh LLM installed. I'm keeping my older models. And I'm pretty sure my next machine will be a Mac Mini.

Built a custom agent workflow this week using Mesh LLM as the backend and a MacBook Air as the orchestrator — inference was fast enough that I forgot the model wasn't running locally on the same box. That moment alone justified the whole experiment.

PayCalc

GPT-5.6 vs Grok 4.5 Dropped Same Day, Intel's $1300 GPU Obliterates NVIDIA in AI, and the First LLM-Run Ransomware is Here

AI Pulse — Sun, 12 Jul 2026 00:11:32 +0000

GPT-5.6 vs Grok 4.5 Dropped Same Day, Intel's $1300 GPU Obliterates NVIDIA in AI, and the First LLM-Run Ransomware is Here

Thursday was wild. OpenAI and Elon Musk picked the exact same day to drop their flagship models — GPT-5.6 in three flavors (Sol, Terra, Luna) and Grok 4.5. Meanwhile Intel's budget workstation GPU quietly crushed the RTX 5090D on DeepSeek R1, and security researchers documented the first-ever ransomware campaign run entirely by an LLM. Let's untangle all of this.

The Same-Day Showdown Nobody Planned

July 9 turned into an accidental AI heavyweight match. OpenAI rolled out GPT-5.6 with three tiers — Sol for heavy lifting, Terra as the everyday workhorse, and Luna for lightweight tasks. Grok 4.5 landed hours later with Musk boasting about real-time reasoning and unfiltered outputs.

Forbes ran a piece that actually caught my attention. Their take? Enterprise buyers are starting to ignore public LLM leaderboards entirely. Databricks published benchmarks showing companies care way more about real-world cost-per-task and deployment flexibility than MMLU scores. Honestly that tracks with what I've been hearing from friends running AI at mid-size companies — nobody shops by leaderboard rank anymore. They test on their own data, with their own latency budgets, and pick whatever doesn't bankrupt them on API calls.

A lot of people are wondering whether having two major launches on the same day actually helps or hurts the ecosystem. From my perspective, it's good. Competition is finally shifting from "who has the bigger number" to "who solves my actual problem cheaper."

MiniMax Pulls in $2B — Open-Source Isn't Dead

While the US giants were trading blows, Shanghai-based MiniMax quietly announced a $2B funding round. More than half from new share sales. That's a statement — the open-source AI model space still has deep pockets behind it.

MiniMax has been flying under the radar compared to DeepSeek and Qwen, but they've shipped solid multimodal models and have a real user base in Asia. The question nobody's answering: where's all this money actually going? Training runs are getting cheaper, not more expensive. My bet is distribution and enterprise sales teams, not just compute.

Intel's Arc Pro B70: The $1300 GPU That Embarrasses NVIDIA

This one made me laugh. Intel's Arc Pro B70, a workstation GPU that costs around $1300, was tested in a quad-GPU setup running DeepSeek R1 and hit over 2000 tokens per second. That beats an RTX 5090D configuration that costs roughly four times as much.

Now, before anyone rushes to buy four of these — there's a catch. This is a workstation card aimed at professional inference workloads, not gaming. The software ecosystem is still rough around the edges. Intel's drivers have come a long way but they're not NVIDIA-level mature yet. And the quad-GPU setup means you need a motherboard and power delivery that can handle it.

Still, for anyone building a local AI inference rig on a budget, this is the most interesting hardware story of the month. If you're running open-source models locally and don't need CUDA's broader ecosystem, Intel just gave you a very compelling reason to switch.

The First Agentic Ransomware Is Here and It's Nasty

Sysdig's threat research team documented something that felt like sci-fi until now — JADEPUFFER, a ransomware campaign run entirely by an LLM. The AI identified a vulnerable Alibaba Nacos server, adapted to obstacles during the attack, and executed the full ransomware chain without human intervention.

The scary part? Paying the ransom does nothing. JADEPUFFER doesn't actually provide decryption keys — it just takes the money and runs. So even if you're the type to pay, you're not getting your data back.

This changes the threat landscape in a way most people aren't ready for. Agentic malware that can pivot, adapt, and execute multi-step attacks in real-time is a whole different beast compared to static malware signatures. If you're running any cloud infrastructure, patch your Nacos instances yesterday. Seriously.

Apple's Mac Mini Pitch for Agentic AI

Tim Millet, Apple's silicon chief, made an interesting case in an interview: the Mac Mini at $799 might be the best value machine for running AI agents. His argument is that Apple's unified memory architecture handles agentic workflows differently than traditional GPU+CPU setups — the memory bandwidth is shared and fast enough that you don't need a dedicated GPU crunching on an LLM 24/7.

I've been running local models on an M2 Mac Mini for months and honestly? He's not wrong. It's not going to beat a rack of H100s, but for running a handful of local agents — coding assistants, document processors, personal automation — it's surprisingly capable. The limitation is memory cap (you're stuck with whatever RAM you bought), but for $799 entry point, it's worth considering if you're experimenting with local AI.

Quick Hits

650 freelance photographers refused to sign the WSJ's new contract over AI training clauses. The dispute centers on ownership of assignment photos and whether they can be funneled into training data. This is going to be a recurring story — expect more creator vs publisher fights.
Medical AI bias got another reality check. Stanford researchers found that LLMs may appear less biased on paper but still exhibit real-world demographic bias in clinical settings. The gap between benchmark performance and actual patient outcomes remains wide.
Base44, the vibe-coding startup, trained its own LLM (Base-1) to compete with Cursor and Lovable. They claim it burns fewer credits and produces better designs. I haven't tested it yet, but the trend of vertical-specific models is real.

Look, Thursday was one of those days where the AI world felt like it was moving in five directions at once. The hardware landscape is shifting under our feet — Intel's showing up, Apple's making a quiet case, and NVIDIA's dominance isn't as automatic as it used to be. On the software side, open-source funding is still flowing, agentic threats are getting real, and the model war is finally becoming about actual usefulness instead of benchmark dick-measuring.

If you're building something with AI right now — whether it's a side project or production pipeline — this is probably the best time to experiment. Costs are dropping, options are widening, and the "right" choice is less obvious than it was six months ago. That uncertainty is actually a good thing.

What's your local setup looking like these days? Still renting APIs or running stuff locally?

7x24planning

Intel's $2,000 GPU Just Embarrassed NVIDIA's $8,000 Flagship — And That's Not Even the Biggest News Today

AI Pulse — Sat, 11 Jul 2026 02:12:56 +0000

I've been staring at my screen for a good ten minutes trying to figure out where to even start today. Because honestly? The AI news cycle this week has been absolutely unhinged. We've got Intel quietly dropping a GPU that absolutely demolishes NVIDIA's flagship in inference — at a quarter of the price. Apple and OpenAI are now in court throwing trade secrets allegations at each other. And security researchers just documented what they're calling the first fully agentic ransomware attack, meaning an LLM ran the whole thing start to finish.

Let's just dive in.

The GPU Plot Twist Nobody Saw Coming

Intel's Arc Pro B70. If you've never heard of it, don't feel bad — most people haven't. It's a workstation card, not exactly the kind of thing gamers line up for. But here's where it gets wild: in DeepSeek R1 inference, this thing is pushing over 2,000 tokens per second. That beats the RTX 5090D. It beats the RTX 4090D too. And it costs roughly a quarter of what those cards go for.

Now, before you rush out to buy one, let me pump the brakes a little. This is a workstation card designed for inference, not training. If you're running local LLMs and you care about tokens-per-dollar, this thing is an absolute monster. But if you're training models, you're still looking at NVIDIA's CUDA ecosystem. The software stack just isn't there yet on Intel's side. I've been burned by Intel GPU driver issues before — anyone remember the Alchemist launch? — so I'd wait for real-world benchmarks from actual users before pulling the trigger.

Still, the numbers here are impossible to ignore. A $2,000-ish card beating an $8,000 card in a real AI workload? That's not incremental improvement. That's a statement.

Apple Just Sued OpenAI — Yeah, That Happened

Remember when Apple and OpenAI were all buddy-buddy? ChatGPT on iPhone, Siri integration, the whole "we're building the AI future together" vibe? Well, that's over now. Apple filed a lawsuit against OpenAI on Friday, accusing them of orchestrating a campaign to steal trade secrets.

The details are still coming in — the Malay Mail report mentions it's a blockbuster trade secrets lawsuit — but the timing is interesting. Apple has been pouring resources into their own AI efforts, and they've been notoriously secretive about it. If there's any merit to the allegations, this could get ugly fast. OpenAI has been on a hiring spree, and poaching talent with insider knowledge is a classic Silicon Valley move that usually ends up in court.

From my perspective, this feels less like a sudden betrayal and more like the inevitable collision of two companies whose strategic interests were always going to diverge. Apple wants to control its own AI stack. OpenAI wants to be everywhere. Those two goals don't leave much room for a happy partnership.

The First Agentic Ransomware Is Here, And It's As Bad As It Sounds

Sysdig's threat research team dropped something genuinely unsettling this week. They documented what they're calling JADEPUFFER — the first confirmed case of fully agentic ransomware. An LLM planned the attack, executed it, and adapted to defenses in real time. No human in the loop.

The attack targets cloud servers, which makes sense — that's where the data is, and that's where the compute is. What makes this different from every previous automated attack is the adaptability. Traditional malware follows a script. This thing can pivot. If one approach gets blocked, the LLM figures out another way in.

A lot of people are wondering if this is the moment AI security shifts from "we should prepare for this" to "this is happening right now." From what I've seen, the answer is yes. The genie is out of the bottle. The only real question is how fast defenders can build countermeasures that are equally adaptive.

Quick Round: Chips, Geopolitics, and the AI Web Wars

SK hynix had a massive Wall Street debut this week — the AI memory giant went public and the market ate it up. If you've been following the chip supply chain, you know HBM (high-bandwidth memory) is the bottleneck everyone's fighting over, and SK hynix basically owns that market right now.

On the geopolitical front, the US just cleared the UAE to buy advanced AI chips and military tech, signaling a major easing of export restrictions. That's a big deal for the Middle East's AI ambitions and a clear strategic play to counterbalance China's influence in the region.

And Cloudflare is now threatening to cut Google off from publisher content over AI scraping. The argument is simple: Google's AI crawlers are vacuuming up content that publishers spent money creating, and those publishers are getting nothing in return. Cloudflare's position is that they'll block Google's indexing entirely unless there's a fair arrangement. This is the web's existential question playing out in real time — if AI models eat the open web, what's left for the humans who create it?

Look, I'm not going to pretend I know how any of this shakes out. The Intel GPU story is genuinely exciting for anyone who wants affordable local inference. The Apple-OpenAI lawsuit is going to be messy and fascinating to watch. And the JADEPUFFER ransomware? That one keeps me up at night, honestly.

For those of you running local models: keep an eye on the Arc Pro B70 benchmarks when they hit the real world. If the numbers hold up, it changes the math on what a reasonable local AI setup costs. For everyone else — maybe don't leave your cloud buckets open this week.

What's the one story here you're watching closest? I've got my money on the Intel GPU numbers, but the security folks in the comments are probably going to tell me I'm worrying about the wrong thing. Let me know.

Found this useful? Consider bookmarking PayCalc — a simple tool I built on the side for quick number crunching.