Introducing MCP-first
Why the next generation of software should be built as a secure, fully controllable capability layer first, and why screens are no longer the product.
Cut your LLM bill by 50 to 90%: caching, routing, right-sizing
Practical levers to shrink inference spend without hurting quality, prompt caching, model routing, context discipline, and capability-level budgets.
API-first was for developers. MCP-first is for agents.
API-first was a real step forward, but it answers a different question. Here is what MCP-first adds on top, and why it matters for agent-ready software.
Choosing and upgrading LLM models without the hype
A vendor-neutral framework for picking and switching models, define your eval tasks, weigh cost/latency/quality, run your own evals, and keep models swappable.
On-device or cloud? Choosing where your models run
A decision framework for splitting AI workloads between local and cloud models, privacy, latency, cost, and capability, plus how sensitivity should route the data.
Agents, MCP, and the small-model cost crash: where 2026 is heading
Three durable shifts reshaping how software gets built, agents moving into production, tool/context protocols standardizing, and small models getting good and cheap.
Audit your MCP server with /manifest.ai
There is a machine-readable, normative edition of the MCP-first manifest. Point an LLM at it and get a 40-rule conformance audit of any MCP server in minutes.
Design patterns for long-horizon agents
Patterns that keep multi-step, long-running agents reliable, task decomposition, sub-agent delegation, checkpoints and recovery, self-verification, budgets, and human gates.
Prompting for long-horizon reasoning: effort and self-checks
Techniques that make models reliable on long, multi-step tasks, decomposition, explicit effort budgets, scratchpads, and self-verification passes.
Loop engineering: designing the system that drives the agent
The model is only half the system. The other half is the loop around it, observe, plan, act, verify, retry, stop, and the guardrails that keep it honest.
Using LLM agents for large-scale code migrations
How to run a framework upgrade or codebase-wide refactor with agents, discovery, per-file transforms, verification, isolation, and review gates that keep it safe.
Self-hosting open models without a GPU farm
When local inference makes sense, and how quantization and right-sizing let capable open-weight models run on modest hardware, with the tradeoffs spelled out.
AI data retention and compliance: what to get right
A practical guide to handling personal and sensitive data in AI systems, minimization, retention, redaction, audit trails, and the data-subject rights you must honor.
Browser-using agents: power and peril
Agents that drive a real browser can do almost anything a user can, which is exactly why they need capabilities, confirmation, and audit, not a free hand.
Multi-agent systems: when one agent isn't enough
Orchestrator/worker patterns, specialization, and shared context, plus the failure modes (cost blowups, loops, compounding errors) and how to contain them.
Guardrails: building AI that's safe by design
Model-level alignment is not enough. Real safety comes from the system around the model, input/output checks, permissions, confirmation, and audit.
Vector databases and embeddings: a practical primer
What embeddings are, how similarity search works, and how to choose and operate a vector store without over-engineering it.
RAG: giving models the right context, not all of it
Retrieval-augmented generation explained, chunking, embedding, retrieval, and the discipline of feeding a model only the context a task actually needs.
Function calling and tool use: how agents actually act
How models go from text to action through typed tool definitions, and why the quality of your tool schemas decides how reliable your agent is.