Metaheuristic - Applied AI partner

Delta verification: assert the change, not the state

Tue, 14 Jul 2026 00:00:00 +0000

The eval dashboard says your flow-builder agent passed again last night. Twenty runs, twenty green. Then a customer asks why none of their flows exist, you open the staging workspace, and the truth is ugly: the agent’s create call has been returning 401 since an API key rotated two weeks ago. Every one of those green runs proved nothing. The verifier checked flow_count >= 1 at the end of each run, and the workspace it ran in has held a handful of flows since March. The assertion was true before the agent spent a single token.

depwal: a dependency firewall for pip and poetry

Sat, 11 Jul 2026 00:00:00 +0000

The dangerous moment in a Python project is not when you write code. It is when you type pip install. That command reaches out to an index, downloads an archive built by a stranger, and runs their setup.py as your user, with your environment variables, your SSH keys, and your cloud credentials sitting one os.environ away. You have not imported anything yet. You have not read a single line of what you pulled. The code already ran. And here is the part people miss: pip install --dry-run runs it too, because pip has to build the package to learn what it needs.

Elwen: a probe harness that tests what you just shipped

Tue, 07 Jul 2026 00:00:00 +0000

Something quietly broke in the last year. We got very fast at shipping. A new endpoint, an auth change, a data migration, a tweak to a page layout - the kind of change that used to take a day now takes an agent twenty minutes. But the way we check that change still assumes the old speed: write assertions against fixtures, run them, ship, and hope staging matched reality.

The assertions only cover what you already thought of. That was fine when a human wrote every line and knew where the bodies were buried. It is not fine when the model wrote the diff and neither of you has poked the running thing yet.

The abstraction tax: MCP versus a plain CLI

Tue, 07 Jul 2026 00:00:00 +0000

Open a fresh agent session, connect the ten MCP servers your team has standardized on, and watch the token counter before you have typed a single instruction. It is already deep into five figures. The servers loaded every tool they expose - names, descriptions, JSON schemas, enum values, field-level docs - straight into the model’s context, and they did it eagerly, all of them, whether or not this particular task will touch a single one. You are paying rent on capability you are not using. That is the abstraction tax, and once you see it you cannot unsee it: the Model Context Protocol buys you a tidy integration story by charging your context window up front, on every request, forever.

How Claude keeps from calling tools in a cycle

Mon, 06 Jul 2026 00:00:00 +0000

Give a capable model a set of tools and a hard problem, and most of the time it does something impressive. But every so often it gets stuck in the least glamorous failure mode there is: it calls search("q3 revenue"), reads the result, decides it is not quite enough, and calls search("q3 revenue") again. And again. The tool returns the same thing every time, because the world did not change between calls - but the model keeps hoping it will.

The blackboard pattern for multi-agent memory

Sun, 05 Jul 2026 00:00:00 +0000

Put two agents in a room and they need a way to share what they have learned. The tempting design is direct messages: the researcher agent calls the writer agent, which calls the critic agent, which calls back. Within a week you have a tangle where every agent imports every other, and adding a fourth agent means editing the other three.

The Blackboard pattern, invented for the Hearsay-II speech understanding system in the 1970s, solves it by removing the direct connections entirely. Agents never talk to each other. They read from and write to a shared structured memory - the blackboard - and a controller decides who acts next. It is a beautiful fit for multi-agent systems, and it is barely a hundred lines of Python.

State of AI dev - June 2026: the month the demo stopped counting

Tue, 16 Jun 2026 00:00:00 +0000

There’s a sentence that showed up, almost verbatim, in three different client kickoffs this month: “It worked in the demo.” It’s always said as a defense and it always means the same thing - the thing was built, somebody recorded a Loom, and then it met real users, real permissions, and real data volume, and it fell over. June was the month the wider industry stopped pretending the demo was the hard part. A widely-shared piece on the forward-deployed engineer put it plainly: a RAG chatbot over 10 documents “works like magic” in the honeymoon phase, but move it to thousands and “efficiency, accuracy and security collapse under the weight of unmanaged complexity” (iNews24). That collapse is the entire job now. This is what we saw.

The agent loop: ReAct from scratch

Wed, 10 Jun 2026 00:00:00 +0000

Strip away the framework marketing and an LLM agent is embarrassingly small: a loop that asks a model what to do, does it, feeds the result back, and repeats until the model says it is done. The 2022 ReAct paper (Reason + Act) gave this loop its name and its shape. Everything else - tool registries, routers, memory - is scaffolding around this one control-flow skeleton.

In this article we build that skeleton in plain Python. No framework, one small dataclass, and a loop you can read in a single sitting. By the end you will have a working agent and, more importantly, a mental model precise enough that every framework you touch afterward looks like a variation on the same theme.

The rise of skill-matched, momentum-driven code reviews (and the fall of the static review queue)

Fri, 08 May 2026 00:00:00 +0000

For most of the last fifteen years, code review meant the same thing in every shop: a human wrote a pull request, another human picked it up sometime between this afternoon and never, and a third human eventually merged it. The loop was slow because the cost of writing code was high, so a few hours of latency on top didn’t matter.

That assumption has quietly evaporated. The model now writes the diff in seconds. The queue still takes a day. The bottleneck moved.

Privacy Policy

Mon, 01 Jan 0001 00:00:00 +0000

This Privacy Policy explains what we collect when you work with Metaheuristic, how we use it, and the controls you have. We try to keep it short and concrete.

1. What we collect

Account & contact data. Email, name, organization, and details you submit through our contact form or during an engagement.

Client Materials. Documents, code, data, and system access you provide so we can deliver an engagement (an audit, build, or retainer).

Talk to us

Mon, 01 Jan 0001 00:00:00 +0000

Terms of Service

Mon, 01 Jan 0001 00:00:00 +0000

These Terms of Service (“Terms”) govern your access to and use of Metaheuristic (“we”, “us”, “our”) - an applied AI agency that designs, builds, and operates production AI systems such as agentic workflows and permission-aware RAG. By engaging us, signing a statement of work, or using anything we deliver, you agree to these Terms together with the applicable engagement agreement.

1. Who can use the service

You must be at least 18 years old and able to enter into a binding contract. If you engage Metaheuristic on behalf of a company, you represent that you have authority to bind that company.