The Rise of Loop and Harness, and Why PromptQL Makes It Easy

Scroll through LinkedIn or tech Twitter this month and one phrase keeps jumping out: loop engineering. A few weeks ago almost nobody said it. Now it's everywhere — and the startling part is who's saying it. The people who build the world's leading AI coding agents say they've largely stopped writing prompts at all.

As Claude Code's creator put it: "I don't write the prompt anymore. Claude writes the prompt." An OpenAI engineer was blunter: "You shouldn't be prompting agents anymore. You should be designing loops that prompt your agents."

That's the shift everyone's buzzing about. And it turns out PromptQL was built for it from day one.

So what is loop engineering?

Think about how you used to work with AI. You typed a prompt, read the answer, typed the next prompt, read the next answer — you, the human, in the driver's seat for every single step. That was the era of prompt engineering: crafting the perfect individual instruction.

Loop engineering moves up a level. Instead of typing each message, you design a repeatable system — a "loop" — that sets a goal, sends the agent off to work, checks the result, and re-prompts it automatically, again and again, until the job is done. You stop being the person typing every line and become the manager who designed the job. As one founder described it: "Just imagine you're onboarding an employee."

A loop, in practice, is just a recurring rhythm:

1. Set a goal — tell the agent what "done" looks like.
2. Let it work — it gathers what it needs and takes action.
3. Verify — it (or a second agent) checks the result.
4. Repeat — it course-corrects and keeps going until the goal is met.

The people championing this — engineers at Anthropic, OpenAI, and Google — describe wiring agents to "wake up every few minutes," pick up tasks, and keep working on their own. The idea has gone viral because it's a genuine change in what your job becomes: less typing, more designing.

But every loop needs a body: the harness underneath

Here's the part the hype tends to skip. A loop can't run on thin air. To set a goal, work, verify, and repeat, the agent needs:

• a memory to carry results from one run to the next,
• tools and data to actually take action,
• a safe workspace so it can't do damage,
• checks so it can verify its own work,
• and guardrails so an automatic loop doesn't run away.

That whole supporting body around the raw model has a name too: the agent harness. And building it is harness engineering — the trend that went viral just before loop engineering did.

The relationship is simple, and it's the key to this whole article:

• Prompt engineering — writing one good instruction. You do the thinking every time.
• Harness engineering — building the body around the model so it can actually do things: memory, tools, a safe workspace, knowledge of your business, checks.
• Loop engineering — the newest layer, sitting on top of the harness: wiring up the recurring loops so the agent keeps working, verifies itself, and improves without you babysitting each step.

Loops ride on the harness. A loop is only ever as good as the harness beneath it. Which means the real question isn't "can I write a loop?" — it's "do I have a harness strong enough to run one safely?" For almost everyone, building that harness is the hard, technical part. PromptQL hands it to you already built.

The heartbeat PromptQL already runs on

Look closely at how the best AI agents work and they all share the same core rhythm — the leading coding agents call it the "agentic loop," in three beats:

1. Gather context — find the relevant information, understand the situation.
2. Take action — make the change, run the query, do the thing.
3. Verify — check the result, learn from what came back.

Then repeat, course-correcting through dozens of little steps until the job is done — and you can jump in at any moment to steer it.

PromptQL runs on exactly this heartbeat. Ask it something, and it gathers context (your wiki, your data), takes action (writes and runs a query, builds a chart, calls a tool), and verifies — looping until it has a trustworthy answer. It keeps you in the loop the whole time, and because several people can sit in the same conversation, it's not just you — your whole team can be. Same loop the cutting-edge agents use, made multiplayer and pointed at your business instead of a codebase.

Why PromptQL already wins at loops

Today's loop talk is almost entirely about coding — engineers wiring agents to maintain their code repos, with worktrees, scripts, and glue code to hold it together. PromptQL takes the very same idea and points it at your whole business, with none of the wiring:

The loop is already running. Ask PromptQL anything and it performs the gather-context → act → verify loop you saw above. You don't assemble it — it's the heartbeat of the product.

Recurring loops, in plain English. The parts loop engineers hand-build — automations, scheduled runs, sub-agents, verification, persistent memory — are all native here. Tell PromptQL "check this every morning and flag anything off," and you've just designed a loop. No worktrees, no scripts, no code.

Memory that survives between runs — and is shared. A loop is only as good as what it remembers from last time. PromptQL's self-writing wiki is that memory, pooled across the whole team, so every loop gets smarter over time instead of starting cold.

The two big loop risks, already handled. Practitioners warn that loops can quietly burn enormous amounts of compute and drift off the rails. PromptQL keeps humans in the loop, enforces who-can-do-what at the data layer, and lets you decide where the agent must stop and check in — so an autonomous loop never turns into an expensive, unsupervised one.

Loops you run as a team. A loop here isn't one engineer's private script. Several people can sit in the same loop, steer it, and teach it — turning loop design from a solo coding trick into something a sales, finance, or ops team does together.

And it works beyond code. The whole loop conversation is stuck on software engineers maintaining repos. PromptQL points the exact same machinery at sales, finance, operations, and support — anyone who can describe the job they want done.

That's the punchline: loop engineering is the new ceiling everyone's reaching for, but a loop is helpless without a strong harness under it. PromptQL gives you both, already built — so you skip straight to designing the job.

The harness underneath — and how PromptQL already has every piece

Loops are only as good as the harness they ride on, so it's worth seeing how complete PromptQL's harness already is. Most people building this today assemble these by hand — slow, technical work. In PromptQL, every piece already exists:

A memory and a workspace. Every conversation gets its own workspace, and the results it produces — tables, charts, reports, files — are saved as artifacts you can keep, share, and revisit. Nothing evaporates between loop runs.

Hands to actually do things. PromptQL connects to your databases and everyday tools (spreadsheets, ticketing systems, CRMs, docs) and lets the AI safely read from them and take action — pull the numbers, draft the email, update the record.

A safe room to work in. Everything the AI does runs inside a protected sandbox, so it can be powerful without being risky. For heavier technical work it can even hand off to specialized coding agents.

A manager who keeps it honest. PromptQL works in careful steps, verifies what it does, and keeps clear records of how it reached an answer — so you can trust the result instead of just hoping it's right.

A handbook about your business — that writes itself. A model knows the whole internet but knows nothing about your company. PromptQL's answer, its self-writing wiki, is so central it gets its own section below.

Why PromptQL is the better way

Knowing PromptQL gives you loops and the harness they need is one thing. Here's why it's a better foundation than rolling your own.

It's already built, so you skip the hard part. Most of harness engineering is plumbing. PromptQL hands you a finished, professionally maintained harness on day one, so you spend your energy designing the loop, not the scaffolding.

The knowledge grows by itself — and it's shared. Keeping the AI's handbook current is usually a never-ending chore someone owns. PromptQL makes it a side effect of normal work, pooled for the whole team. Your loops get smarter every day, with no dedicated caretaker.

It's safe enough to hand to a whole company. Strict, built-in rules govern who can see and touch what — boundaries the AI cannot talk its way around. Each person's loops only ever see what that person is allowed to see.

It plugs into your real world. A loop is only as good as what it can reach. PromptQL connects to your actual data and tools where they already live — no giant migration, no months of setup before you see value.

The wiki as your team's shared brain

Here's the piece almost everyone underestimates — and the thing that makes loops actually compound instead of starting cold every time.

A model knows the whole internet but nothing about your company. It doesn't know that "active customer" means something specific to you, or which of your five revenue numbers is the real one. That knowledge — the stuff in people's heads and scattered Slack threads — is exactly what separates a useful assistant from a confidently wrong one. A great harness needs a memory to store this and search it at the right moment. PromptQL's answer is its wiki — a genuine shared brain, not a dump of notes.

Why a wiki, specifically? Because it's how humans have always organized collective knowledge. Each page is one idea, written in your own business language — a term, a metric, a customer, a process — and pages link to related pages, just like Wikipedia. When the assistant needs to understand your question, it lands on the pages that matter and follows the links to pull in exactly the context it needs. That structure lets it scale to a whole company's knowledge without becoming an unreadable mess.

Why the wiki is the cure for "context rot." Here's a problem that quietly wrecks most AI loops. An AI has a limited working memory — a mental desk it can spread things out on. The longer a loop runs, the more clutter piles onto that desk: every document it opened, every dead end it tried. Past a point it gets overwhelmed and turns sloppy — forgetting what it was doing, contradicting itself, losing the thread. People call this context rot. The naive fix — give the AI a bigger desk — doesn't work; a bigger pile is still a pile, and the important things still get buried.

The wiki solves this at the root by changing where knowledge lives. Instead of dumping everything onto the AI's desk, knowledge stays neatly filed on wiki pages until the moment it's needed. Ask a question, and the assistant pulls only the handful of relevant pages onto its desk, follows their links, and leaves the rest in the cabinet. It's the difference between memorizing an entire filing cabinet and walking over to pull the one folder you need. The desk stays clear, the focus stays sharp — and the AI can draw on a whole company's knowledge without ever being buried by it. The counterintuitive payoff: a bigger company brain makes the agent sharper, not foggier, because it always has more of the right page to reach for.

It learns continually, in the flow of work. You never sit down to write a manual. As you work with PromptQL and correct it, it notices what it just learned and offers it back as a suggested note. You glance, tweak if needed, and click "add to wiki." That lesson is now permanent — tomorrow's loops get better because of today's correction. The brain gets smarter every time anyone uses it.

A human is always in the loop. Some AI memory systems quietly teach themselves overnight, with no one checking what they absorbed — so they can silently bake in mistakes and nobody notices until it's wrong at scale. PromptQL does the opposite: knowledge enters the brain only when a human approves it. The result is a memory you can actually trust.

It's truly shared, and it's yours. What one person teaches, everyone's loops instantly know. The new hire gets the institutional memory of the ten-year veteran on day one. The knowledge isn't trapped in one head or rented inside a vendor's system — it's your organization's own asset, growing under your control.

That's why the wiki is the heart of it all. Tools give the AI hands; the wiki gives it understanding — and a memory that makes every loop compound.

Further reading: On Shared Context

The best part: anyone can be a loop engineer

Here's where it gets genuinely exciting.

Read about loop engineering today and it sounds like a job for a small elite of engineers — people writing code, wiring worktrees, and hand-building the harness underneath. That's true for the do-it-yourself path, and it puts this capability out of reach for almost everyone.

PromptQL erases that barrier. Because the harness is already built and the loop already runs, the only thing left to shape is the part that's uniquely yours: your knowledge, your rules, your way of working. And you shape it not by coding, but by talking. Have a conversation. Correct the assistant when it's off. Click "add to wiki." Ask it to check something every morning. That's it — you just engineered a loop, without touching a line of code.

What that means in practice:

• A salesperson teaches it how their pipeline really works, and sets a loop that prepares accounts and drafts follow-ups every morning.
• A finance analyst explains how the company defines revenue, and gets reports that run and come out right on their own.
• An operations lead describes the messy reality of their process, and gets a tireless loop that watches and flags issues around the clock.
• A support team pools what it knows, and every loop answers like its most experienced member.

None of them write code. None of them touch infrastructure. Each ends up with a real, running loop — and the capable harness beneath it — tuned to their corner of the business simply by using it and teaching it in plain language.

That's the quiet revolution. The loop and the harness, not the model, are where the value lives — and PromptQL does the hard engineering for you, leaving you the easy, human part: just describe the job, and share what you know.

The model thinks. The harness works. The loop keeps it going. And with PromptQL, anyone can build all three.