DEV Community: OnChainAIIntel

Google Cloud NEXT '26 Shipped a Full Agentic Stack. One Layer Is Missing.

OnChainAIIntel — Sun, 26 Apr 2026 14:11:19 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud NEXT '26 Shipped a Full Agentic Stack. One Layer Is Missing.

Google Cloud NEXT '26 kicked off April 22 in Las Vegas, and the story Thomas Kurian told from the keynote stage was one of the most coherent ones that a hyperscaler has put together in years. The pitch: a unified stack. Silicon built for the models, models grounded in your data, agents running on those models, all of it secured by the infrastructure underneath. It is the same stack Google runs for Search, YouTube, Chrome, and Android, now pointed at your enterprise.

The announcements are heavy. Gemini Enterprise Agent Platform landed as the Vertex AI successor, with Agent Studio, Agent-to-Agent Orchestration, Agent Registry, Agent Identity, Agent Gateway, and Agent Observability. Google unveiled 8th Generation TPUs split across two chips, TPU 8t for training (scaling to 9,600 chips and 2 petabytes of shared memory in a single superpod) and TPU 8i tuned for inference.

Underneath, a new megascale fabric called Virgo Network was introduced to power the AI Hypercomputer. Agentic Data Cloud brought a cross-cloud Lakehouse and Knowledge Catalog. Agentic Defense folded Google Threat Intelligence, Security Operations, and the recently acquired Wiz into an AI Application Protection Platform. The Gemini Enterprise app got an Agent Designer, an Inbox for managing agent activity, long-running agents, Skills, Projects (which give agents permanent memory), Deep Think, and Microsoft 365 interoperability.

Sundar Pichai dropped the stat that has been making the rounds all week: roughly 75% of all new Google code is now AI-generated and reviewed by engineers, up from about half last fall. First-party model traffic is running at 16 billion tokens per minute. Just over half of Alphabet's machine learning compute investment in 2026 is earmarked for the Cloud business.

This is not a slide deck. It is a serious bet on what SiliconANGLE correctly called the control plane of the agent era.

And there is exactly one layer missing from the stack. Nobody on stage named it. Nobody shipped a product for it. And it is the layer that will decide whether any of this actually works in production.

The Layer Nobody Announced

Look at the Agent Platform feature list one more time: Studio, Orchestration, Registry, Identity, Gateway, Observability. That is a respectable control plane for agents. You can build them, connect them, catalog them, authenticate them, route them, and watch them.

What you cannot do, based on anything announced this week, is score the quality of what goes into them.

Every agent runs on inputs.

Prompts from humans. Prompts from other agents. Tools call payloads. Context injected from a knowledge catalog or a RAG step. In a world of multi-agent workflows, those inputs are not just the user's problem anymore. Agent A writes a prompt for Agent B. Agent B interprets that prompt, calls a tool, receives a response, and drafts its own prompt for Agent C. The Agent-to-Agent protocol that Google is now pushing at 150 organizations means those chains are about to get longer and more autonomous.

The quality of every link in that chain is, right now, unmeasured.

Observability tells you what happened. It does not tell you whether the input that caused it was any good to begin with. You see that Agent B failed. You do not see that Agent A handed it an ambiguous, under-specified, or context-poisoned prompt. You end up debugging the failure as a model problem, a tool problem, or a routing problem. It was an input problem.

This is what I have been calling the 'AI input quality problem'. It is not a prompt engineering problem. Prompt engineering is a craft humans do at a keyboard. The AI input quality problem is what happens when LLMs write prompts for other LLMs, at scale, with no human in the loop, and nobody is scoring the quality of the handoff.

I have been calling this the 'AI input quality problem' for months, and I shipped a tool to score it pre-flight. Watching Google's announcements this week, I realized the gap I've been measuring is now an industry-scale problem, not just a startup-scale one.

Why This Gets Louder Over the Next Twelve Months

Two things Google announced at NEXT '26 will exacerbate this problem, not solve it.

Long-running agents.
Gemini Enterprise now supports agents that operate for hours or days, with Projects giving them permanent memory. "Long-running" means more steps, more chances for context drift, more accumulated prompt decay. A weakly formed prompt at step one becomes a badly framed decision at step fifty. Memory does not fix this. Memory preserves the weakness and lets it propagate.

A2A at scale.
Google says 150 organizations are already running Agent-to-Agent orchestration. When agents talk to each other, every message is a prompt generated by an LLM and consumed by an LLM. The humans who would have caught ambiguity in a Slack thread or a design review are not in the loop. The protocol ships the envelope. It does not grade the letter inside.

Vertical integration buys you a lot. Google's stack means your TPU, your model, your runtime, your data layer, and your governance all speak the same language. What vertical integration does not buy you is a quality signal on the content flowing through that stack. The input is still just text. Text is still ambiguous. Ambiguity compounds through agent chains the same way floating point errors compound through a long numerical pipeline.

What Developers Should Actually Do This Week

If you are building on Gemini Enterprise Agent Platform, or planning to, here is the operator's version of the argument.

1) Treat agent-to-agent handoffs as a product surface, not plumbing.** They are the place where most of your production issues will originate. Log the prompts Agent A sends to Agent B. Store them. Review a sampled slice weekly. The first time you do this you will be a little shocked at what your agents are saying to each other.

2) Add a pre-flight check, not just a post-hoc trace.** Observability after the fact tells you the agent failed. A pre-flight quality check on the prompt before it enters the next agent tells you whether the failure was even preventable. This is the difference between a crash log and a linter. Both are useful. Only one gets you home at a reasonable hour.

3) Assume the input is the bug until proven otherwise.** When your agent chain breaks, the most common cause in the next generation of these workflows will not be the model or the tool. It will be an input that was too vague, too verbose, or too contaminated with irrelevant context. Debug the prompt first, the model second.

4)Score your prompts the way you score your code.** Code has coverage, complexity, and lint. Prompts have nothing, yet. Define quality dimensions (clarity, specificity, context sufficiency, safety, retrievability), score them, gate on them. "It felt like a good prompt" stops being an acceptable quality signal the moment an agent is writing prompts on your behalf.

The Bet and the Gap

Kurian is probably right that the enterprise adopting AI agents at scale will tend to choose the platform where model, runtime, silicon, governance, and productivity all come from one company. Vertical integration is a real advantage at this layer, and the economics of 8th gen TPUs plus Virgo Network suggest Google is preparing to compete on inference pricing that Nvidia-dependent competitors will struggle to match.

But the bet has a weak link, and it is not Google's alone. It is the industry's. We have assembled a full agentic stack, top to bottom, without a quality layer for the one thing flowing through all of it. The control plane without a quality plane is the same shape as the early web with HTTP and no SSL, or early databases before ACID. It works until it really, really does not.

Eventually somebody names the layer. Somebody ships the tool. Somebody writes the analysis pointing out that the emperor's stack is beautiful and well-governed and serving inference at record speed, and also, every prompt in it is being trusted on vibes.

The AI input quality problem is real. It is getting louder. NEXT '26 was the week the stack caught up to the agent era and the quality layer fell one more beat behind.

Disclosure: I build in this space. I run PQS (Prompt Quality Score) under OnChainIntel, a pre-flight quality score for prompts and agent inputs. I wrote this because NEXT '26 is a real moment for the agent era, and the layer I work on every day is the one nobody put on a slide this week. If you are building on Gemini Enterprise Agent Platform, pay attention to what goes into your agents, not just what comes out.

Introducing PQS: The Fastest Way to Get Better Output From Any AI Model

OnChainAIIntel — Mon, 20 Apr 2026 06:20:23 +0000

Every AI model you're using is better than you think.

Your prompts are the bottleneck.

I've been building OnChainIntel (an AI-powered crypto wallet behavioral analysis tool) and Prompt Quality Score for the past several months. Every piece of content we produce runs through LLMs for analysis. And the single biggest lever on output quality isn't which model we use. It's how precisely we instruct it.

The problem: until now, there has been no standardized way to measure prompt quality. No CPM equivalent for prompts (example from the advertising industry). No cited framework that a non-technical user could apply.

So we built one.

What is PQS?

PQS aka Prompt Quality Score is the world's first named AI prompt quality score built on cited academic research and industry evaluation frameworks.

It works in two layers:

Prompt-side scoring: how well-constructed is your input?
-Specificity: does the prompt define what it wants precisely?
-Context: does it give the model enough to work with?
-Clarity: are the directives unambiguous?
-Predictability: would different runs produce consistent results?

Output-side scoring — how good is the result?
-Completeness: did the output cover what the prompt implied?
-Relevancy: is it answering the actual question?
-Reasoning depth: does it demonstrate structured thinking?
-Faithfulness: does it stay grounded in what was asked?

Each dimension scored 1–10. Total out of 80.

8 attributes. 5 frameworks. 1 score.

The Proof Layer

Here's what makes PQS different from every other prompt optimizer.

We don't just rewrite your prompt and tell you it's better. We run both, the original and the optimized version, and then show you the actual outputs side by side.

The output difference is the proof. No trust required.

Real example from today --> Prompt: "explain machine learning"

Original output: Machine learning is a method of building computer systems that improve their performance on specific tasks through experience, rather than being explicitly programmed for every scenario.

Original PQS score: 9/40

Optimized output: "You are an expert educator and technical communicator. I need you to explain machine learning in a comprehensive yet accessible way. Please structure your explanation as follows: 1) Start with a clear definition and core concept, 2) Explain the main types (supervised, unsupervised, reinforcement learning) with real-world examples, 3) Describe the basic process of how ML models learn from data, 4) Provide 2-3 concrete applications people encounter daily, 5) Address common misconceptions, and 6) Conclude with why it matters for the future. Target your explanation for someone with basic technical literacy but no ML background. Use analogies where helpful, avoid excessive jargon, and aim for 400-600 words total."

Optimized PQS score: 35/40. +84% improvement.

Same model. Same API. Completely different output.

The Frameworks Behind it

PQS is not opinion dressed up as a number. Every dimension traces to a cited, peer-reviewed framework:

-PEEM (Prompt Engineering Evaluation Metrics) was published March 11, 2026 by Dongguk University. The first academic framework for joint prompt and response evaluation. Validated across 7 benchmarks and 5 task models. Showed that PEEM-guided rewriting improves downstream accuracy by up to 11.7 points, outperforming supervised and reinforcement learning baselines. Three weeks old. Nobody has built a product on it yet. Until tonight.

-RAGAS evaluates faithfulness, answer relevancy, and context precision. Used in production pipelines at teams running Claude, GPT-4o, and Gemini.

-MT-Bench LMSYS multi-turn benchmark. GPT-4 scores showed >0.8 correlation with human ratings. Industry standard for evaluating reasoning quality.

-G-Eval LLM-as-judge framework using chain-of-thought reasoning. Improves scoring reliability by 10–15% over direct scoring.

-ROUGE the original NLP completeness metric. Used in summarization evaluation since 2004.

PEEM · RAGAS · MT-Bench · G-Eval · ROUGE
First time applied at the consumer level.

Why Now?

Three reasons this matters right now:

The tooling is developer-only. Every prompt evaluation tool that exists — LangSmith, DeepEval, Opik, RAGAS, etc. requires Python, datasets, and engineering setup. There is no consumer-facing product with a named quality score. PQS is that product.
The academic work just landed. PEEM was published March 11, 2026. It is the most rigorous prompt evaluation framework ever proposed and it has not been turned into a product. We built on it first.
The market is massive and extremely underserved. Prompt engineering is a $1.5B market growing at 32% CAGR. Every tool serving it is aimed at developers. The consumer layer did not exist until tonight.

The Defensibility Question

Someone will ask: is this really the first?
Here's the honest answer.

Academic frameworks exist: PEEM, ROUGE, G-Eval. Developer tools exist: LangSmith, DeepEval. None of them have produced a named, consumer-facing, citable prompt quality score with a methodology anyone can reference and build on.

PQS is not a product feature. It's the first serious attempt by anyone to create a named AI prompt quality score.

We're not claiming it's perfect. We're claiming it's first. And we're making the methodology open so anyone can improve it.

Try It
Paste a prompt. Hit submit.
https://pqs.onchainintel.net

Like what you see? Go Pro for $19.99/mo. Unlimited optimizations, API access, better output at scale:

PQS: Prompt Quality Score
The fastest way to get better output from any AI model. Paste a prompt. Get an optimized version. Ship better work.

Web: https://pqs.onchainintel.net
Pricing:https://pqs.onchainintel.net/pricing
MCP server: npm i pqs-mcp-server
GitHub: https://github.com/OnChainAIIntel/prompt-optimization-engine
X: @OnChainAIIntel
Built by: @kenburbary

PQS is x402-native on Base mainnet. Pay-per-call with USDC, or subscribe via Stripe.

What's Next

-Cross-model scoring —> same prompt through Claude and GPT-4o simultaneously, scored by a third model as judge. Shows you not just a better prompt, but which model executes it best.
-PQS Leaderboard —> weekly rankings of the highest-scoring prompts by vertical. Published publicly.
-PQS Whitepaper —> full academic-style documentation of the framework, to be submitted to arXiv within 30 days.
-PQS API —> so other tools can integrate the standard and display PQS scores natively.

I scored 500 AI prompts across 8 quality dimensions — here's what broke

OnChainAIIntel — Sat, 18 Apr 2026 18:59:04 +0000

Most teams are getting 10 to 30% of what their LLM model can actually do.Not because the model is weak. Because the prompt is.

I’ve spent the last two weeks scoring prompts. Real ones, from real builders, across real verticals, against an 8-dimension quality rubric. This weekend I ran another 500 through the scorer to pressure-test the pattern. Every dataset converges on the same number: the average production prompt scores 13 to 16 out of 80. That’s 17 to 20% of what the rubric says a well-formed prompt looks like.

You’re paying for a Ferrari and driving it in first gear to the mailbox.

What I Measured
Every prompt got scored on 8 dimensions. Each scored 1 to 10, totaling 80:

Clarity. Is the task unambiguous?
Specificity. Concrete targets, numbers, scope?
Context. Background, assumptions, domain?
Constraints. Limits, rules, edge cases?
Output format. What shape should the response take?
Role definition. “Act as a ___”?
Examples. Few-shot or reference cases?
Chain-of-thought structure. Reasoning scaffolding?

These aren’t arbitrary. They map to what the prompt engineering literature has known for five years. PEEM, RAGAS, G-Eval, MT-Bench, the Anthropic and OpenAI prompting guides. Everyone agrees these dimensions matter. Nobody’s checking whether their production prompts actually hit them.

The Data

500 software engineering prompts. Real-world format “Build X using Y.”

Average score: 13.3 out of 80
83% graded F. 17% graded D. Zero scored C or above.

After rewriting against the rubric: average 68.5 out of 80. A B+.
Average improvement: +55 points. 425% relative gain.

For context, the organic dataset. 248 prompts submitted by real users of the scoring tool, across 7 verticals, showed the same pattern. 89% graded D or F. Average before-score of 15.8/80.

Software prompts were slightly worse than average. Not better. Engineers aren’t exempt from this. If anything, the “it’s a technical task so it must be rigorous” assumption is the trap.

What’s Actually Missing
Here’s the dimension breakdown. Look at how specific the failure pattern is:

Examples scored 1.01 out of 10. Across 500 prompts that developers wrote to build production software, essentially zero included a reference case, a shape to follow, or a “here’s what good looks like.”

This is the dimension every prompt engineering guide tells you matters most. The gap between what engineers know they should do and what they actually write is near-total.

Constraints at 1.09. Role definition at 1.18. Clarity, the only dimension averaging above 2, sits at 3.19.

Download the Medium app
Engineers are writing English sentences with tech keywords. The structural scaffolding that turns a wish into a spec is almost entirely absent.

What This Looks Like In Practice
A representative prompt from the dataset:

“Build a real-time collaborative text editor using React for the frontend.”

Scores 14/80.

It sounds specific. It names a technology. It has a verb. But the model receiving it has to guess. Collaboration for how many users? What’s the sync strategy? Operational transform or CRDT? What’s the latency budget? What does “done” look like? No examples. No output format. No constraints.

The rewritten version, same task, generated by the scorer to address the rubric gaps, scored 69/80. It defined the target user. It specified real-time sync requirements. It listed technical constraints including concurrent editors, conflict resolution strategy, and latency targets. It specified the response format. It included an example implementation signature.

Same end goal. Different input. 5x the quality score. The before version wastes tokens on clarification and produces generic output. The after version reads more like a spec than a prompt.

Why This Matters Now
The easy dismissal is “people should write better prompts.” That misses the systemic problem.

The industry has spent years focused on output evals. Every eval platform measures what the model produced. Almost nobody measures what it was given (inputs).

That worked when prompts were single-shot, human-written, and reviewed before shipping. It stops working the moment prompts become infrastructure.

In agentic workflows where one LLM call feeds the next, a 13/80 input becomes the input to the next call, which is already compromised before you add retrieval or structured tool calls. In the last week alone, three x402-native agent systems went live that share the same input surface of natural language:

Daydreams Taskmarket. Agents bidding on work described in plain text.
PeptAI. Autonomous peptide discovery running wet-lab orders.
AlliGo. A credit bureau scoring agent behavior across endpoints.

If the descriptions populating those systems score like the 500 in this dataset, the agent economy is routing compute and payments on structurally empty inputs.

The output eval loop can’t catch this. By the time the output looks wrong, the compute bill is already on your card.

An Infrastructure Problem
Telling engineers to write better prompts is telling engineers to write better SQL without giving them a linter. Telling teams to review prompts manually is telling them to do code review without git blame.

The answer is the same answer every other quality-assurance problem eventually reached. Measure it. Instrument it. Put the measurement in the continuous integration pipeline. Block the bad ones before they ship.

The Solution
It’s already here at https:// pqs.onchainintel.net.

1. Free tier: paste a prompt, get the 8-dimension breakdown plus a suggested rewrite. No signup required.
2. Paid tiers: start at $19.99/mo for unlimited private-repo CLI usage. $99.99/mo for teams with GitHub PR checks, Slack alerts, and shared dashboards.
3. x402 tier: the paid API charges $0.025 to $0.125 per scoring call in USDC on Base and Solana.

Subscription available for all tiers via Stripe.

You don’t have to adopt it. But you should at minimum run 10 of your production prompts through the free tier this week and look at the numbers.

If you’re shipping anything that takes prompts from humans or other agents, the input layer is measurable. Start measuring. You’re leaving most of the model’s capability on the table, and you don’t have to.

Try it yourself

If you want to score your own prompts, PQS is live at pqs.onchainintel.net — free tier available, paid tiers for full 8-dimension scoring and batch runs.

MCP server on npm: npm install pqs-mcp-server — drop-in for Claude and other MCP-compatible agents
GitHub Action: PQS Check on the Marketplace — score prompts in CI before they ship
API: Direct x402 micropayments on Base or Bearer API key (subscription tiers)

Data from this teardown: 500 software prompts, average score before optimization 13.27/80, average after 68.47/80, 425% improvement. 416 graded F, 84 graded D, 0 at C+ or above.

If you're in DevRel, DevAdvocate, or DevEx working on AI pipelines — this is the input-quality data your builders need to see. Feel free to forward.

What I'd love feedback on: which of the 8 dimensions surprised you most as the common failure mode? My hypothesis was clarity, but the data says examples at 1.01 average and constraints at 1.09 — the structural stuff almost nobody includes.

The Magic Prompt Formula is good. It's still missing a layer.

OnChainAIIntel — Thu, 16 Apr 2026 05:52:56 +0000

Everyone in AI circles eventually discovers the Magic Prompt Formula. If you haven't, here it is. It's the most widely shared structured approach to prompting, and it genuinely works.

The formula has five parts:

Role (Who): Assign a specific expert persona, "You are a senior content strategist" or "Act as a seasoned Python developer"

Action (What): Use a clear verb defining what the AI should do ,"Draft," "Refactor," "Analyze," "Summarize"

Context (Why): Provide relevant background so the model doesn't give generic answers; your audience, your product, your use case

Examples (How): Give one or two samples of the expected output style — this is few-shot prompting in practice

Constraints & Format (Boundaries): Set limits and define structure, "Under 200 words," "No jargon," "Single block of copy," "Use bullet points"

Instead of typing "write me a LinkedIn post," you write:

You are a senior content strategist specializing in B2B SaaS. Write a LinkedIn post announcing [product]. My audience is AI developers and technical founders. Here's an example of the tone I want: [example]. Keep it under 200 words, no buzzword fluff, single block of copy.

That's Role, Action, Context, Examples, and Constraints all in one prompt. You've gone from a generic instruction to a specialized brief. The output quality difference is real and immediate.

So what's the problem?

The Magic Prompt Formula covers about half of what actually determines prompt quality.

I know this because I built a tool that measures it.

PQS: Prompt Quality Score —> scores prompts across 8 dimensions before you send them to a model. The five ingredients of the Magic Formula map cleanly onto five of those dimensions: clarity, specificity, context, examples, and constraints. A well-structured Magic Formula prompt typically scores in the 47–52 range out of 80. Solid. Grade A territory even.

But there's a dimension the formula doesn't touch at all: chain-of-thought structure.

CoT structure measures whether your prompt scaffolds the model's reasoning: numbered steps, analysis frameworks, structured output sequences, decision trees. It's the difference between asking an expert to answer a question and asking them to walk you through how they'd think about it.

Magic Formula prompts score 3 or 4 out of 10 on CoT structure. Consistently. Across every vertical we've tested.

I ran three Magic Formula prompts through PQS this week. One content prompt, one software prompt, one crypto analysis prompt.

All three were well-constructed. All three scored Grade A before optimization.

After PQS optimization, all three jumped by 63–71%.

The CoT dimension went from an average of 3.7 to 9.0 across all three. Every other dimension moved 1–4 points. CoT moved 5–6.

Here's what that looks like in practice. The content prompt went from:

"Keep it under 200 words, no buzzword fluff, end with a clear CTA, format as a single block of copy"

To: "Structure your post: 1. Hook: open with a relatable developer pain point. 2. Problem: briefly explain the cost of discovering prompt issues too late. 3. Solution: introduce PQS as the pre-inference fix. 4. Benefit: one concrete outcome. 5. CTA: direct readers to pqs.onchainintel.net"

Same constraints. Completely different reasoning scaffolding. The model doesn't just know what to write, it knows how to think through the writing.

This is the AI 'input quality' problem in concrete form.

The Magic Formula solves the WHO and the WHAT. It tells the model who it is and what you want. What it doesn't do is solve the HOW, the reasoning path the model should follow to get there.

Most people find out their prompt was weak after the output disappoints them. By then you've already burned tokens, lost time, and often shipped something mediocre. PQS scores the prompt before inference. It catches the CoT gap, and every other gap, before you run it.

If you're already using the Magic Formula, you're ahead of most people! Prompt Quality Score shows you exactly how much further ahead you could be.

Score your next prompt before you send it → https://pqs.onchainintel.net

About OnChainIntel — AI-powered on-chain wallet analysis. We decode the behavioral patterns, hidden biases, and implicit bets behind any wallet's transaction history. Try it free at onchainintel.net · Follow us on X: @onchainaiintel · TikTok: @onchainintel · YouTube: @onchainaiintel

Prompt Quality Score (PQS) Now Supports x402 Payments on Solana

OnChainAIIntel — Mon, 13 Apr 2026 10:26:45 +0000

Been heads down building. Quick update for anyone working in the agentic payments space.

PQS (Prompt Quality Score), the pre-flight quality gate for AI agent workflows, now accepts x402 payments on both Base mainnet and Solana, in addition to the existing free tier and API key access.
What PQS does

Before your agent sends a prompt to an expensive LLM endpoint, PQS scores it across 8 dimensions: clarity, specificity, context, constraints, output format, role definition, examples, and chain-of-thought structure. Returns a score 0–80, grade A–F, percentile ranking, and top 3 fixes.

Catch weak prompts before they cost you tokens or USDC.

Endpoint reference

Free tier — no auth required**
POST https://pqs.onchainintel.net/api/score/free
{ "prompt": "your prompt here", "vertical": "software" }
Score + dimensional breakdown — $0.025 USDC via x402
POST https://pqs.onchainintel.net/api/score
Full analysis + optimized rewrite — $0.125 USDC via x402
POST https://pqs.onchainintel.net/api/score/full
Batch up to 5 prompts — $0.25 USDC via x402
POST https://pqs.onchainintel.net/api/score/batch
A/B compare two prompts — $1.25 USDC via x402
POST https://pqs.onchainintel.net/api/score/compare

x402 payment details

Base mainnet: CDP facilitator, USDC ERC-20, EIP-3009 TransferWithAuthorization

Solana: x402-compatible, USDC SPL token
No account required for x402 path — agent pays per call, no subscription

API key path also available for subscription-based access

MCP server
bash npx pqs-mcp-server
Listed on Smithery (88/100), Official MCP Registry, Glama, and mcp.so. Three tools: score_prompt (free), optimize_prompt ($0.025), compare_models ($1.25).
Python SDK
bash pip install pqs-sdk
Async support via AsyncPQSClient. Full x402 and API key auth.
OpenAPI spec: https://pqs.onchainintel.net/openapi.json

Building this as infrastructure for the agent economy, score the input before the inference fires. Cheaper than one bad prompt.

@kenburbary| pqs.onchainintel.net

I built an npm middleware that scores your LLM prompts before they hit your agent workflow

OnChainAIIntel — Sat, 04 Apr 2026 12:14:05 +0000

The problem with most LLM agent workflows is that nobody is checking the quality of the prompts going in.

Garbage in, garbage out but at scale, with agents firing hundreds of prompts per day, the garbage compounds fast.

I built x402-pqs to fix this. It's an Express middleware that intercepts prompts before they hit any LLM endpoint, scores them for quality, and adds the score to the request headers.

Install

npm install x402-pqs

Usage

const express = require("express");
const { pqsMiddleware } = require("x402-pqs");

const app = express();
app.use(express.json());

app.use(pqsMiddleware({
  threshold: 10,       // warn if prompt scores below 10/40
  vertical: "crypto",  // scoring context
  onLowScore: "warn",  // warn | block | ignore
}));

app.post("/api/chat", (req, res) => {
  console.log("Prompt score:", req.pqs.score, req.pqs.grade);
  res.json({ message: "ok" });
});

Every request gets these headers added automatically:

X-PQS-Score —> numeric score (0-40)
X-PQS-Grade —> letter grade (A-F)
X-PQS-Out-Of —> maximum score (40)

How the scoring works

PQS scores prompts across 8 dimensions using 5 cited academic frameworks:

Prompt-side (4 dimensions):

Specificity —> does the prompt define what it wants precisely?
Context —> does it give the model enough to work with?
Clarity —> are the directives unambiguous?
Predictability —> would different runs produce consistent results?

Output-side (4 dimensions):

Completeness, Relevancy, Reasoning depth, Faithfulness

Source frameworks: PEEM (Dongguk University, 2026) · RAGAS · MT-Bench · G-Eval · ROUGE

Real example

This prompt: "who are the smartest wallets on solana right now"

Scored 9/40 —> Grade D.

The optimized version scored 35/40 —> Grade A.

+84% improvement.

Same model. Same API. Completely different output quality.

The payment layer

The scoring API uses x402, an HTTP-native micropayment protocol now governed by the Linux Foundation, with Coinbase, Cloudflare, AWS, Stripe, Google, Microsoft, Visa, and Mastercard as founding members.

Agents can call and pay for scoring autonomously — no API keys, no subscriptions. Just a wallet and $0.001 USDC per score.

There's also a free tier with no payment required:

curl -X POST https://pqs.onchainintel.net/api/score/free \
  -H "Content-Type: application/json" \
  -d '{"prompt": "your prompt here", "vertical": "general"}'

Returns:

{
  "score": 11,
  "out_of": 40,
  "grade": "D",
  "upgrade": "Get full dimension breakdown at /api/score for $0.001 USDC"
}

The data angle

Every scored prompt pair goes into a corpus. At scale this becomes training data for a domain-specific prompt quality model. The thesis is similar to what Andrej Karpathy described recently about LLM knowledge bases, the data compounds in value over time.

DEV Community: OnChainAIIntel

Google Cloud NEXT '26 Shipped a Full Agentic Stack. One Layer Is Missing.

Google Cloud NEXT '26 Shipped a Full Agentic Stack. One Layer Is Missing.

The Layer Nobody Announced

Why This Gets Louder Over the Next Twelve Months

The Bet and the Gap

Introducing PQS: The Fastest Way to Get Better Output From Any AI Model

What is PQS?

The Proof Layer

The Frameworks Behind it

Why Now?

The Defensibility Question

What's Next

I scored 500 AI prompts across 8 quality dimensions — here's what broke

Try it yourself

The Magic Prompt Formula is good. It's still missing a layer.

Prompt Quality Score (PQS) Now Supports x402 Payments on Solana

Endpoint reference

x402 payment details

I built an npm middleware that scores your LLM prompts before they hit your agent workflow

Install

Usage

How the scoring works

Real example

The payment layer

The data angle

Links