MCP · PiniShv

WordPress Just Let AI Agents Publish to 43% of the Web. Now What?

Sun, 22 Mar 2026 19:00:00 +0200

On March 20, WordPress.com announced that AI agents can now write, edit, and publish posts on any WordPress.com site through MCP. Not just draft. Publish. The agent can also manage comments, update metadata, fix alt text, organize tags, and read the site’s design system to match its visual style.

WordPress powers 43% of all websites. That’s 20 billion pageviews and 409 million unique visitors a month on the hosted platform alone.

They just gave AI agents a publish button to nearly half the web.

What it actually looks like
#

You connect your preferred AI client (Claude, ChatGPT, Cursor, or anything MCP-enabled) through wordpress.com/mcp. Then you tell it what you want in natural language. “Write a post about our Q1 product updates, match our brand voice, schedule it for Tuesday.” The agent drafts it, formats it to your site’s design system, and publishes.

Posts default to draft status. All actions get tracked in the Activity Log. User role permissions are enforced: Contributors can draft but not publish. There are guardrails. But the core capability is clear: an AI agent can now autonomously manage a publication pipeline end-to-end.

This builds on MCP support WordPress introduced in October 2025, which was read-only at the time. The jump from “read my site” to “publish to my site” happened in five months.

Meanwhile, YouTube is going the other direction
#

In January 2026, YouTube terminated 16 channels with a combined 4.7 billion views and 35 million subscribers. The reason: mass-produced AI content with little to no human involvement. Channels running AI voiceovers over Wikipedia articles. Fake movie trailers. Repetitive content with minor variations pumped out daily.

YouTube’s updated monetization policy is explicit: content with “little to no human involvement” doesn’t get monetized. YouTube CEO Neal Mohan said the platform “welcomes creators using AI tools to enhance storytelling” but draws the line at AI replacing storytelling entirely.

Two of the biggest content platforms on the internet. One just made autonomous AI publishing easier than ever. The other is actively punishing it.

What’s actually happening here
#

The divergence makes sense when you look at what each platform values.

WordPress is infrastructure. It doesn’t care what you publish. It cares that you use WordPress to publish it. More content, more sites, more hosting revenue. Opening MCP write access makes the platform more useful for the agentic era. If AI agents are going to generate content at scale, WordPress wants to be the rails.

YouTube is an attention marketplace. It cares deeply about what gets published because its revenue depends on people watching. AI slop that nobody wants to watch degrades the product. YouTube has a direct financial incentive to filter, because advertisers don’t pay for content humans skip.

The difference isn’t philosophical. It’s economic. WordPress sells picks and shovels. YouTube sells eyeballs.

The SaaS connection
#

I wrote recently about how the SaaS bargain is breaking. The old model was: rent generic software because custom is too expensive. AI collapsed the cost of custom. Same thing is happening with content.

The old model was: pay for a platform because creating and managing content at scale was hard. WordPress just made it trivially easy. An agent can maintain an entire content pipeline. So what’s the platform’s value when the hard part disappears?

WordPress is betting the value shifts from “helps you create content” to “is where content lives.” Infrastructure, not interface. That’s a defensible position if they’re right.

But the WordPress announcement and the YouTube crackdown point to the same underlying question: when content becomes nearly free to produce, how do you maintain quality? WordPress’s answer is “that’s your problem.” YouTube’s answer is “that’s our problem, and we’ll enforce it.”

For anyone building on either platform, the lesson is the same one from the SaaS article: the value isn’t in the generating anymore. It’s in the judgment, curation, and trust layer on top.

AI can publish to 43% of the web now. The question isn’t whether it will. It’s whether anyone will want to read what it publishes.

Experimenting with AI-driven content workflows? Seeing the quality shift on platforms you use? I’d love to hear what you’re noticing. Find me on X or Telegram.

Open WebUI Isn't a ChatGPT Clone. It's AI Infrastructure.

Wed, 18 Mar 2026 10:00:00 +0200

Here’s a question nobody’s asking: who owns the layer between your engineers and the AI models they use every day?

Right now, for most teams, the answer is OpenAI. Or Anthropic. Or Google. Your engineers open ChatGPT, or Claude, or Gemini, and they work inside someone else’s product. Someone else’s UI. Someone else’s data policies. Someone else’s feature roadmap.

That’s fine when AI is a nice-to-have. It stops being fine when AI becomes how your team actually works.

Open WebUI is the project that makes this question real. Not because it’s a better chatbot. Because it turns the AI interface layer into infrastructure you can own, deploy, and control. And once you understand what that means, the conversation about AI tooling changes completely.

What Open WebUI actually is
#

Strip away the GitHub stars (128k+ and counting) and the marketing language about “bringing intelligence home.” What you’re looking at is a self-hosted control plane for AI models.

It runs in a container. Docker, Kubernetes, Podman, Helm, whatever your infra looks like. First account becomes admin. Later signups need approval. For a solo setup you can disable login entirely. One container, local storage, browser UI. You’re up and running.

But the interesting design decision is that it’s protocol-first, not vendor-first. Open WebUI uses OpenAI Chat Completions as the shared language across providers. It has compatibility layers for Anthropic. It supports Ollama for local models. It can route to any OpenAI-compatible backend. That makes it less like “an Ollama UI” and more like an operations layer sitting above whatever models you choose to run.

This is the same architectural pattern we’ve seen play out in infrastructure before. Think about how Terraform became the control plane above cloud providers, or how Kubernetes became the orchestration layer above compute. Open WebUI is making that same move for the AI interface layer.

What it can actually do (beyond chat)
#

Most people discover Open WebUI because they want a local ChatGPT. Then they realize the feature surface is much wider than they expected.

RAG and knowledge work. Multiple vector databases, document uploads, URL ingestion, web search across 15+ providers, and full-page URL fetching. This isn’t a toy retrieval setup. It’s a real knowledge pipeline.

Agent capabilities. Open WebUI distinguishes between Tools, Functions, and Pipelines. It supports MCP natively. It can attach external actions like search, scraping, image generation, and voice. It can expose MCP through OpenAPI-compatible flows. This is an agent platform, not just a chat box.

Code execution. Python through Pyodide or Jupyter, Mermaid rendering, interactive artifacts. At the extreme end there’s Open Terminal, which gives the model a real OS-level environment in a container. That’s powerful and terrifying in equal measure.

Team workflows. Folders, projects, chat history, shared conversations, channels for multi-user collaboration, RBAC, SCIM provisioning, OpenTelemetry. The admin surface is deeper than most people expect from an open-source project.

Media and voice. Image generation and editing, speech-to-text and text-to-speech with local, browser, and remote options.

The feature list is impressive. But feature lists are easy. The real question is what happens when you actually run it.

The reality of running it in production
#

For a hobbyist or solo developer, Open WebUI is deceptively simple. Container up, connect a model, start chatting.

For production, the defaults are just defaults. Out of the box you get SQLite, embedded ChromaDB, and one Uvicorn worker. That’s fine for one person. The moment you want multi-worker or multi-node deployment, the project tells you to move to PostgreSQL with PGVector, Redis for caching, and shared storage. Easy to start. Not magically “no-ops” once it matters.

If you use RAG heavily, the reality gets sharper. The project’s own scaling guide warns that the default PDF extractor and default embedding path are common causes of memory leaks and RAM blowups at scale. They explicitly recommend externalizing them in production.

I’m not saying this to dismiss the project. I’m saying it because this is exactly the kind of detail that separates “I read the feature list” from “I actually deployed it.” If you’re considering Open WebUI for your team, go in with eyes open. This is infrastructure. Infrastructure requires ops.

Who’s behind it and why that matters
#

Open WebUI is led by founder Tim J. Baek and backed by Open WebUI, Inc. The team page credits community contributors, but the organization is explicit that it’s not looking for outside governance advice. This is founder-led open source, not a neutral foundation-governed commons.

Why does that matter? Because the business model is visible in the decisions.

Since version 0.6.6, the project added a branding-protection clause for larger deployments. Code up to v0.6.5 remains under the original BSD-3 terms. Enterprise offerings include theming, SLAs, LTS, and direct support. This is the standard playbook: open core with enterprise upsell.

The community has opinions about this. Some people on Hacker News get sharp about the licensing change and the fact that a project called “Open” WebUI has branding restrictions. Others say they don’t care because they’re not planning to fork it anyway.

My take: this is a normal and healthy tension. Building sustainable open-source software costs money. Branding protection is one of the less invasive ways to fund it. But if you’re betting your team’s AI infrastructure on this project, you should understand the governance model you’re buying into.

The security conversation nobody wants to have
#

Here’s the uncomfortable part.

Open WebUI’s Tools, Functions, Filters, Pipes, and Pipelines execute arbitrary Python on your server. The docs say “only install from trusted sources.” That’s honest, but it also means the extension system is a real attack surface.

This isn’t theoretical. A code-injection issue in Direct Connections was patched in 0.6.35. An SSRF issue in retrieval processing was patched in 0.6.37. Both are the kind of vulnerabilities that come with running user-extensible systems.

For your team, this means treating Open WebUI the same way you’d treat any infrastructure component: pin versions, review extensions, monitor for CVEs, control who can install what. The freedom to extend the platform comes with the responsibility to secure it.

Why teams and orgs actually adopt this
#

Features are nice. But nobody migrates their AI tooling because of a feature checklist. They do it because something about the current setup is broken. I spent time researching the best tools for an internal ChatGPT alternative, talking to other engineering leaders who did the same. Here’s what actually drives the decision.

Cost visibility and control. When your team uses ChatGPT or Claude directly, every person needs a subscription. Or worse, everyone shares credentials. Or worst of all, engineers use their personal accounts and company data flows through consumer products with consumer privacy terms. With Open WebUI in front of your API keys, you get one set of credentials, usage tracking per user, and the ability to route different workloads to different models based on cost. Need a quick answer? Route to a cheap local model. Need deep reasoning? Route to Claude or GPT. Same interface, conscious cost allocation.

Data stays where you decide. For a lot of orgs this is the whole conversation. Regulated industries, government contracts, security-conscious startups. The moment your engineers paste proprietary code into ChatGPT, you have a data governance problem. Self-hosting the interface layer means the data flows through your infrastructure, your logging, your retention policies. You can run sensitive workloads on local models that never leave your network, and routine tasks on cloud APIs. Same UI for both.

No vendor lock-in on the workflow layer. This is the one that hits engineering leaders hardest. Today your team builds workflows, prompt libraries, knowledge bases, and habits around ChatGPT. Tomorrow OpenAI changes the pricing, kills a feature, or deprecates a model. Everything you built around their interface is tied to their decisions. When the interface is yours, the models are pluggable. You can switch from GPT to Claude to Gemini to a local model without retraining your team or rebuilding your workflows.

Unified AI experience across the org. Instead of some engineers using ChatGPT, some using Claude, some using local models, and nobody sharing anything, everyone works through one interface. Shared conversations, shared knowledge bases, shared tools. New team member joins, gets access to the same AI setup as everyone else. That might sound like a small thing until you’ve managed an engineering org where every person has their own disconnected AI workflow and none of that institutional knowledge is captured anywhere.

A real sandbox for innovation. Want to test a new model? Add it as a backend. Want to build a custom agent for your team? Use the extension system. Want to integrate your internal knowledge base? Plug in RAG. Want to give your AI access to your tools via MCP? It’s supported. You don’t need to wait for OpenAI or Anthropic to ship a feature. If you can build it, you can plug it in. For teams that move fast, that’s the difference between waiting for a vendor’s roadmap and building what you need right now.

None of this is free. You trade managed simplicity for operational responsibility. But for teams that are serious about AI being part of how they work, not just a tool they occasionally open, owning the interface layer starts making a lot of sense.

How it compares to the incumbents
#

The comparison isn’t really about features. It’s about what you’re optimizing for.

Versus ChatGPT. ChatGPT has Projects, Deep Research, Apps, Company Knowledge, and mature business controls. SSO, retention policies, permissions, training defaults. It’s zero-ops SaaS. Open WebUI’s advantage is that you own the stack. Data stays local. You mix local and remote models. You’re not locked to one vendor’s interface. If zero-ops matters most, ChatGPT wins. If ownership matters most, Open WebUI wins.

Versus Claude. Claude has Artifacts, Projects, Skills, Research, and Google Workspace integration. Anthropic also created MCP. Open WebUI can route to Claude’s models, but Anthropic’s own docs note that their OpenAI-compatible endpoint is mainly for testing, and the native API is recommended for the full feature set including PDF processing, citations, extended thinking, and prompt caching. Protocol compatibility is powerful, but it flattens vendor-specific superpowers.

Versus Gemini. Gemini is strongest when your work already lives in Google’s ecosystem. Deep Research can pull from Search, Gmail, Drive, and NotebookLM. Open WebUI is the better fit if you want one interface above Google models, Anthropic models, OpenAI models, local models, and whatever comes next.

The pattern is consistent: the SaaS products win on managed experience and vendor-native depth. Open WebUI wins on control and independence. Neither is wrong. They’re different bets.

How it compares to open-source alternatives
#

The open-source landscape is more nuanced.

LibreChat is probably the closest direct competitor. Agents, MCP, artifacts, code interpreter, broad provider support. It reads like the closest open-source answer to the mainstream chat products. Open WebUI feels more infrastructure-oriented, more invested in deployment patterns, admin controls, and the local/offline story.

AnythingLLM leads with “chat with your docs.” Built-in agents, multi-user support, vector databases, document pipelines, no-code agent builder. If your center of gravity is private documents and internal knowledge workflows, AnythingLLM has a clear story. Open WebUI is broader if you want one extensible front end for many kinds of AI workflows.

Onyx is enterprise-search-heavy. Connectors, synced knowledge sources, deep research, MCP, enterprise knowledge grounding. Compelling when “AI over company knowledge” is the main requirement. Open WebUI is a general AI workspace. Onyx is sharper as an enterprise retrieval layer.

Jan is desktop-first and personal. 100% offline, runs on your laptop, turns it into an AI workstation. Great for single-user local AI. Open WebUI becomes more compelling the moment you want browser access, shared workspaces, or team deployment.

What this actually means for engineering leaders
#

Here’s the strategic point that matters more than any feature comparison.

For the last two years, the AI interface layer has been bundled with the model provider. You use ChatGPT because you want GPT. You use Claude because you want Anthropic’s models. The interface and the intelligence came as a package deal.

Open WebUI (and projects like it) are unbundling that. The model is one layer. The interface is another. And once those layers separate, the dynamics change.

Your team can switch models without switching workflows. You can run sensitive workloads on local models and routine work on cloud APIs, through the same interface. You can add RAG, agents, and custom tools without waiting for OpenAI to ship them. You can audit, log, and control every interaction.

The price of that freedom is real. You own deployment. You own patching. You own extension security. You own operational tuning. You inherit everything that SaaS normally hides behind a login page.

That’s not a reason to avoid it. It’s a reason to approach it the way you’d approach any infrastructure decision: with clear requirements, honest assessment of your ops capacity, and a plan for what happens when things break at 3am.

Who should care about this
#

If you’re a solo developer who wants a better local AI setup, Open WebUI is probably the best option out there right now. Install it, connect your models, enjoy.

If you’re an engineering leader evaluating AI tooling for your team, Open WebUI is worth understanding even if you don’t deploy it. It represents where the AI tooling ecosystem is heading: model-agnostic interfaces, self-hosted control planes, protocol-first architectures. The question isn’t whether this pattern wins. It’s how fast.

If you’re already running AI agents in production (like I am), Open WebUI is interesting as the potential front end for your entire AI operations layer. One interface for your agents, your knowledge base, your model routing, your team’s AI workflows. That’s a compelling vision. Whether the project can deliver on it at enterprise scale is still an open question.

Either way, the conversation has shifted. It’s no longer just about which model is best. It’s about who controls the layer where your team meets the model. Open WebUI is one of the first projects to take that question seriously.

And that’s worth paying attention to.

Running self-hosted AI infrastructure? Thinking about owning the interface layer? I’d love to hear what you’re using. Find me on X or Telegram.

Your AI Agents Are Flying Blind. Here's How to Fix That.

Sun, 15 Mar 2026 10:00:00 +0200

Your AI agent just rewrote the authentication flow. The code is clean. Tests pass. The PR looks great.

One problem: it broke the SSO integration with three enterprise customers because it didn’t know the auth service has a contract with the identity provider that requires a specific token format. That contract lives in a Slack thread from 2023 and one engineer’s head.

The agent didn’t make a mistake. It made a perfectly reasonable decision with the information it had. The information it had was almost nothing.

This is happening across your codebase right now. Not just with authentication. With everything. Business rules, API contracts, deployment constraints, database conventions, service boundaries. Your agents write code that compiles, passes tests, and violates assumptions that live nowhere except in people’s heads and scattered documents nobody maintains.

I’ve written about why context is the fundamental problem in AI. I’ve written about putting AI agents on the org chart and managing them like team members. But none of that matters if the agents start every session blind.

If you’re running agents in production, this is the problem you need to solve next.

Two teams, same agents, wildly different results
#

Let me describe what I’m seeing.

Team A has agents embedded in their development workflow. An agent picks up a ticket to add a new validation rule to the user registration flow. Before writing a line of code, it queries a knowledge base and gets back: the existing validation rules, the reason the email format check is stricter than RFC 5322 (because of a legacy migration), the API contract with the notification service, and the team’s convention for error handling. The agent writes code that fits. The PR gets approved on the first review.

Team B has the exact same agents, same models, same IDE. Their agent picks up a similar ticket. It reads the code in the repo, sees patterns, generates a solution. The solution uses a different error handling pattern than the rest of the codebase. It changes the validation response format, which breaks the mobile client. It adds a database column without following the team’s migration conventions. The PR gets three rounds of review comments and a refactor.

Same AI. Same capability. Completely different outcomes.

The difference isn’t the model. It’s that Team A solved the knowledge problem and Team B didn’t.

Where knowledge actually lives (and why that’s broken)
#

In most engineering organizations, critical knowledge is scattered across:

People’s heads. The worst possible storage medium.
Slack threads. Searchable in theory, buried in practice.
Confluence pages. Written once, updated never.
Code comments. Spotty at best, misleading at worst.
Tribal knowledge. “Ask Daniel, he built that service.”

None of this is accessible to AI agents. None of it is structured for retrieval. None of it stays current.

And here’s the compounding problem: as AI agents do more work, the knowledge gap matters more, not less. When humans wrote all the code, at least the person writing it carried the context. When agents write the code, the context has to come from somewhere else. Or it doesn’t come at all.

Think about it this way: a senior developer who’s been on your team for three years carries hundreds of micro-decisions in their head. Why the payment service retries exactly three times. Why the user permissions check happens at the API gateway, not the service layer. Why that database query uses a specific index hint. Now imagine replacing that developer with an agent that knows none of this. That’s what you’re doing every time an agent starts a session.

The wrong way to fix this
#

The instinct is to throw more code at the agent. Bigger context windows. More files in the prompt. RAG over the entire codebase.

I’ve seen teams try this. Here’s what happens:

They dump the entire repo into the context. The agent drowns in irrelevant code and can’t find the signal, and every token costs money, so you’re paying premium rates to confuse your own agents. They build RAG over Confluence. The retrieval returns pages from 2021 that contradict how things actually work. They write massive README files. Nobody maintains them. Within three months they’re more misleading than helpful.

And the costs compound. More tokens in the context means higher API bills on every single request. Bad context leads to wrong code, which leads to longer review cycles, which leads to rework, which means more agent sessions with the same bad context. It’s compound interest working against you. Every layer of waste multiplies the next.

The problem isn’t volume of information. It’s the right information, maintained, structured, and delivered at the moment the agent needs it. Get this wrong and you’re not just getting bad code. You’re paying more for it with every iteration.

What actually works: a developer knowledge hub
#

After months of thinking about this problem and looking at how every available solution falls short, I believe the answer is a system with three components that work together.

Layer 1

Source of Truth

📁

Knowledge Repo (Git)
Developers author markdown: product rules, system docs, architecture specs, skills

▼ CI/CD syncs on every merge ▼

Layer 2

Index & Push

🔍

Vector Store + Embeddings
Chunk, embed, index → semantic search

📄

AGENTS.md + Skills per repo
Generated context + reusable workflows

▼ Serves queries at dev time ▼

Layer 3

Universal Bridge

🔌

MCP Server
One server → every IDE & agent can query knowledge

▼

Consumers

All tools

💻

Cursor Claude Code Copilot Codex Kiro + any future MCP-compatible tool

Git for authoring
#

Not Confluence. Not Notion. Not some SaaS product with its own editing UI.

A Git repository. Markdown files. Pull requests for review. CI/CD for automation. The same workflow developers already use for code.

Why Git? Because the adoption problem kills every knowledge initiative that requires developers to learn a different tool. PRs already have review workflows. Blame shows who wrote what. History shows when things changed. CODEOWNERS controls who can approve what. Your developers already know all of this. Zero adoption friction.

The repo holds four types of knowledge:

Product knowledge. Business rules, domain logic, edge cases, validation requirements. Why the user registration flow requires that specific email format. Why the discount calculation has a different rounding rule for enterprise customers. This changes every sprint.

System knowledge. Build commands, repo structure, coding conventions, database patterns, module boundaries. Why you always run migrations before the test suite. Why the cache invalidation uses event sourcing instead of TTL. This changes when code changes.

Architecture knowledge. API contracts, data flows, service boundaries, system invariants. Why the payment service is the only service allowed to write to the transactions table. Why the notification queue has exactly-once delivery semantics. This changes rarely but matters enormously.

Operational skills. Code review checklists, debugging guides, feature scaffolding patterns, cross-repo change workflows. How to add a new API endpoint. How to set up a feature flag. How to run a database migration across services. How the CI/CD pipeline works, which checks run on PR, which run on merge, what gates production. How linting and formatting are enforced and what to do when a check fails. How to roll back a deployment. How to triage a failing build. These are reusable agent workflows that encode how your team actually works. Not just the code, but the entire delivery process around it.

One thing you’ll notice is missing from this list: the code itself. That’s intentional. AI IDEs and coding agents like Cursor, Copilot, and Claude Code already do a solid job indexing your codebase. They understand file structure, imports, function signatures. You don’t need to duplicate that work. What they can’t index is everything around the code. The why, the rules, the decisions. That’s what the knowledge hub is for. That said, the system is designed to be agile. If you want to add code indexing, documentation from other sources, or any other category of data, the architecture supports it. Same Git authoring, same search layer, same MCP delivery.

Semantic search for retrieval
#

Raw markdown is great for humans. Useless for agents that need to find the right three paragraphs out of thousands for a specific task.

This layer chunks the markdown by section, embeds it into vectors, and indexes it for semantic retrieval. When an agent asks “what are the validation rules for the registration flow?” it gets the relevant sections, with citations back to the source documents.

AWS Bedrock Knowledge Bases does this out of the box. So does Pinecone, Weaviate, or any vector store with a decent chunking strategy. The specific tool doesn’t matter. What matters is that knowledge becomes semantically searchable, not just keyword-matchable.

CI/CD syncs markdown to the search index on every merge. Knowledge stays current automatically. No manual re-indexing. No stale embeddings.

MCP for delivery
#

Here’s where it comes together.

Your developers use Cursor, Claude Code, Copilot, Codex, Kiro. Probably several of them. Each one is an island. Each one starts every session without context.

Model Context Protocol (MCP) is the open standard that connects all of them. I wrote a deep dive on MCP earlier. If you haven’t read it, start there.

One MCP server wraps your knowledge base and exposes it to every IDE and agent through a standard interface. Build one server. Every tool connects natively. New tools that support MCP work automatically. Zero per-tool maintenance.

The server exposes three tools: search_knowledge for semantic search across all knowledge, get_document to fetch a specific doc by path, and list_knowledge_bases to discover available sources. Simple interface, massive impact.

Without MCP: You build a separate integration for each IDE. Maintain six connectors. Each tool gets knowledge differently. Every new tool means new work.

With MCP: You build one server. Everything connects. When the next AI coding tool launches next month, it just works.

The loop that makes it compound
#

Here’s where this gets really powerful. The system doesn’t just serve knowledge. It grows.

🔍

Read

Agent queries KB
via MCP

→

💻

Work

Develops with
full context

→

📝

Write Back

Opens PR to
knowledge repo

→

✅

Merge

Dev reviews
CI re-indexes

↩

🔄

Updated

Next session
starts smarter

Fully automated. No manual curation. Knowledge grows as the team develops.

The workflow in detail:

Agent reads. Before starting work, queries the knowledge base via MCP. Gets business rules, conventions, architecture constraints relevant to the task.
Agent works. Develops with full context. The code actually follows the patterns and rules.
Agent writes back. A built-in skill instructs the agent to capture what it learned during development and open a PR to the knowledge repo.
Developer reviews. Standard PR review. Approves or refines the knowledge doc.
CI syncs. Merged knowledge is automatically indexed. Next agent session starts smarter.

Knowledge capture becomes part of development, not a separate chore. The developer just reviews. No separate authoring step.

There’s a sixth step that takes this even further. When new knowledge merges, a CI step can run an LLM over the diff and ask: “What else in the entire knowledge base might be affected by this change?” Remember, this is a centralized system across all your repos. A change to how one service handles authentication could affect product knowledge for three other services, architecture docs for the API gateway, and operational skills for the deployment pipeline. The system uses embeddings to find related documents across every domain, checks for contradictions or staleness, and opens follow-up issues flagging what might need updating. Ripple effect detection across your entire engineering knowledge. You update the validation rules for user registration, and the system flags that the API contract doc, the mobile client integration guide, and the error handling conventions might all need a second look. It’s cheap to run and catches the kind of cross-cutting knowledge drift that humans miss because nobody has visibility into every document across every team.

Every feature built makes the next feature easier. Every agent session makes the next session smarter. The knowledge compounds.

The AGENTS.md safety net
#

Not every agent session has MCP access. Sometimes developers work offline. Sometimes a new tool doesn’t support MCP yet. Sometimes the knowledge server is down.

For these cases, CI generates a lightweight AGENTS.md in each repo. It’s a table of contents for the agent: what this repo does, how to build and test it, architecture boundaries, conventions and constraints, and where to find the full knowledge base.

Think of it as the offline fallback. Agents get essential context even without network access. Push model (always in-repo) complementing the pull model (on-demand via MCP).

Why nothing on the market solves this
#

I looked at many solutions out there. Each solves a piece, and the approach I’m describing borrows the best parts from all of them.

Meta-repos (centralized Git docs). Git-native authoring, but no semantic search. Agents can’t find what they need.

Wiki + RAG (Confluence/Notion with retrieval). Searchable, but not Git-native. Developers won’t update it. Knowledge rots within months.

Code wikis (auto-generated from code). Clever, but usually tied to one AI tool. Not universal.

Cloud RAG services (Bedrock KB, Vertex). Managed search, but no authoring story. Where does the content come from?

Agent memory (Copilot memory, Letta). Per-tool, per-session. Not centralized. Not shared across the team.

You need all five capabilities in one system. That’s what this approach delivers.

How to start (without boiling the ocean)
#

Day 1: Create the knowledge repo. Sit with your two or three most senior engineers, the ones who carry the most context in their heads. Ask them: “What do you find yourself explaining over and over?” That’s your first knowledge document.

Day 2-3: Set up semantic search. Connect your markdown to a vector store. Get retrieval working. This is not a multi-week project. The tooling exists. Use it.

Day 4-5: Deploy the MCP server. Configure it in your team’s primary IDE. Have a developer pair with an agent on a real task and compare the output to what they’d get without the knowledge base. That’s your first signal.

Week 2: Add the write-back loop. Build the skill that instructs agents to capture knowledge after completing work. Train your developers on how to review knowledge PRs, not just code PRs. This is where it starts compounding.

The technology side of this is days of work. The harder part is getting your team to treat knowledge as a first-class deliverable, not an afterthought. That’s a leadership problem, not a tooling problem. But once developers see their agents producing better code because someone took 20 minutes to document business rules, the culture shift happens on its own.

We’re in the AI era. If the infrastructure takes you months, you’re overengineering it. Get something working in days, iterate from there. The humans will make it great.

The key insight: start with the knowledge that hurts most when it’s missing. That’s usually the domain logic, the business rules that experienced developers carry in their heads and that agents get wrong in ways that look correct until they hit production.

The uncomfortable question
#

If your AI agents are generating code without context, how much of that code is actually correct?

Not “does it compile” correct. Not “does it pass the tests you wrote” correct. Actually correct. Follows the business rules, respects the architecture, uses the conventions, handles the edge cases that burned you last quarter.

If you can’t answer that confidently, your agents aren’t helping as much as you think. They’re generating plausible-looking code that somebody has to review against all the unwritten knowledge that exists only in people’s heads. And you’re paying for every token of that wrong output, then paying again for the review, again for the rework, and again when the agent generates the same mistake tomorrow because nothing changed.

That’s not an AI problem. That’s a knowledge management problem. And it’s solvable.

The organizations that figure this out first will have AI agents that don’t just write code. They write the right code. Every time. From session one.

That’s the difference between AI as a novelty and AI as a genuine multiplier. And it’s what separates teams that are actually shipping with agents from teams that are just generating code and hoping for the best.

Building knowledge systems for AI agents? Thinking about MCP? I’d love to hear how you’re approaching it. Find me on X or Telegram.

Model Context Protocol: The Missing Connection Between AI and Your Real Work

Tue, 30 Sep 2025 00:00:00 +0000

Your AI coding assistant can write impressive code. But it can’t read your company’s database schema, your internal documentation, or your production logs. It doesn’t know your team’s conventions, your deployment workflows, or why that weird workaround exists in the payment service.

This is the context gap. And it’s why AI tools feel powerful in demos but limited in real work.

The Model Context Protocol (MCP) is changing that. Not with better models or smarter prompts, but by standardizing how AI connects to the actual systems where your work lives.

Here’s what you need to know, what you can do today, and why this matters more than most AI announcements.

The problem MCP solves
#

AI assistants live in a bubble. They see what you show them: the current file, maybe the conversation history, perhaps a few documentation snippets you paste in.

What they don’t see:

Your database tables and relationships
Your API schemas and internal services
Your Git history and commit patterns
Your company’s documentation and decision records
Your production metrics and error logs
Your team’s code conventions and architectural patterns

Every time you switch contexts, you’re starting over. The AI has to relearn. You spend time explaining things it should already know.

The traditional solution: Build custom integrations. Write a plugin that connects Claude to your database. Write another for ChatGPT. Another for Cursor. Maintain them all as things change.

This doesn’t scale. Three AI tools, five data sources, fifteen custom integrations. Then a new AI tool launches and you start over.

MCP solves this by standardizing the connection layer. Build once, use everywhere.

What MCP actually does
#

MCP is an open protocol that lets AI applications connect to three types of capabilities:

1. Resources (what AI can read)

Your databases, files, documentation, APIs. Anything that provides context the AI needs to understand your work.

Example: Your database exposes its schema as an MCP resource. Now Claude can see your table structure without you pasting it into the chat.

2. Tools (what AI can do)

Search operations, API calls, data queries, workflow triggers. Actions the AI can take on your behalf.

Example: A search tool lets the AI query your documentation. A database tool lets it run read-only queries. A Git tool lets it analyze commit history.

3. Prompts (how AI should think)

Templated workflows for specific tasks. Structured ways to guide AI behavior for your team’s common patterns.

Example: A code review prompt that includes your team’s specific conventions. An incident analysis prompt that knows your logging structure.

Understanding the architecture (if you’ve built APIs, you’ll get this)
#

If you’ve worked with REST APIs, MCP will feel familiar. It’s the same pattern applied to AI integrations.

REST API thinking:

Server exposes endpoints (GET /users, POST /orders)
Client makes requests to those endpoints
Standard protocol (HTTP) means any client can talk to any server
Authentication and authorization control access

MCP thinking:

Server exposes resources, tools, and prompts
Client (AI application) discovers and uses those capabilities
Standard protocol (JSON-RPC) means any MCP client can talk to any MCP server
Host (container for the AI) enforces permissions and approval

The three-layer architecture
#

1. Server (your systems)

The MCP server wraps your existing systems and exposes them through a standard interface. This is like building a REST API for your database, except instead of HTTP endpoints, you’re exposing MCP resources and tools.

Example: Your PostgreSQL database gets an MCP server that exposes:

Resources: schema definitions, table structures
Tools: query execution (read-only to start)
Prompts: common analysis patterns your team uses

2. Client (the connection layer)

The MCP client sits between the AI and the servers. It discovers what’s available, routes requests, and handles responses. Think of it like an API gateway, but for AI integrations.

The client handles:

Connection management to multiple servers
Capability negotiation (what does this server support?)
Message routing and response handling
Security boundaries enforcement

3. Host (the orchestrator)

The host is the container that manages everything. It controls which servers the AI can access, enforces approval flows for sensitive operations, and mediates access to the AI model itself.

This is the security and policy layer. Even if a server offers dangerous tools, the host can require explicit user approval before the AI can invoke them.

How it compares to other integration patterns
#

Like REST APIs:

Standard protocol that anyone can implement
Server/client architecture with clear separation
Discoverability (list available endpoints/resources)
Stateless individual operations, stateful sessions

Like GraphQL:

Clients can discover the schema (what’s available)
Type-safe interactions with JSON Schema validation
Flexible queries for exactly what you need

Like OAuth:

Explicit permission and consent flows
Scoped access to resources
User remains in control of what AI can access

Unlike traditional APIs:

Bidirectional communication (servers can request things from clients)
Built-in support for streaming responses
Designed specifically for AI-to-system integration
Security model assumes untrusted AI behavior

The transport layer (how data moves)
#

MCP uses two primary transports:

stdio (standard input/output): For local processes. The MCP server runs on your machine, communicates through stdin/stdout. Simplest and most secure for desktop applications. This is how Claude Desktop connects to local servers.

Streamable HTTP: For remote servers. JSON-RPC over HTTP with server-sent events for streaming. Use this when you need team-wide access to a server or want to deploy servers in the cloud.

Why this matters: Start with stdio (local, simple, secure). Move to HTTP when you need remote access or horizontal scaling.

The protocol is simple (intentionally)
#

MCP uses JSON-RPC 2.0. If you’ve worked with JSON APIs, the message format will look familiar:

{
 "jsonrpc": "2.0",
 "method": "resources/list",
 "id": 1
}

The simplicity is deliberate. Easy to implement, easy to debug, easy to extend.

Why this architecture works
#

Separation of concerns: Servers don’t need to know about AI models. AI applications don’t need to know about your database internals. The protocol is the contract between them.

Composability: One AI application can connect to multiple servers. One server can serve multiple clients. Mix and match based on needs.

Security boundaries: Servers are isolated from each other. The host enforces what the AI can access. Sensitive operations require explicit approval.

Ecosystem effects: When everyone builds to the same protocol, servers become reusable assets. Your PostgreSQL MCP server works with Claude, ChatGPT, and Gemini. Build once, benefit everywhere.

How to start using MCP today
#

This is the important part. You don’t need to build MCP servers to benefit from MCP. Start by using what exists.

Step 1: Install an MCP-compatible client
#

Claude Desktop is the easiest starting point. Download it, and you already have an MCP client ready to go.

Cursor supports MCP through Claude Desktop integration. If you’re using Cursor for coding, this path makes sense.

Other options: Zed, Windsurf, and Sourcegraph Cody all support MCP. Pick the tool you already use.

Step 2: Add your first MCP server
#

Start simple. The filesystem server lets Claude read your local files.

What this gives you: Instead of copying and pasting code into Claude, you can say “read the authentication module and suggest improvements.” Claude accesses the file directly, sees the full context, and gives better answers.

Five minute setup:

Install the filesystem MCP server
Configure Claude Desktop to use it
Point it at your project directory
Now Claude can read your actual codebase

Step 3: Connect to your databases
#

The PostgreSQL MCP server (and similar for other databases) exposes your schema and enables read-only queries.

What this changes: You can ask “show me all users who signed up in the last week but haven’t completed onboarding” and Claude queries your database directly. No copy-paste, no context switching.

The right way to do this: Start with read-only access. Use environment variables for credentials. Test on development databases first.

Step 4: Add Git context
#

The Git MCP server exposes repository history, branches, and diffs.

What becomes possible: “Analyze the last ten commits to the payment service and summarize what changed.” Claude reads the actual Git log and gives you a coherent summary.

Step 5: Connect to your tools
#

Existing MCP servers cover Google Drive, Slack, GitHub, Postgres, and more. The MCP Registry (in preview) is where you find community servers.

Pick what matters to your workflow. Documentation? Customer data? Production metrics? Connect the systems where your context lives.

What changes when AI has real context
#

This isn’t just convenience. It’s a fundamental shift in how you work with AI.

From manual context to automatic context
#

Before: You spend five minutes explaining your database structure, pasting schema definitions, copying relevant code into the chat.

After: Claude already sees your schema. You skip straight to the actual question.

The compounding effect: Over dozens of interactions per day, you save hours of context-gathering work.

From shallow answers to deep understanding
#

Before: AI suggests generic solutions because it doesn’t know your actual constraints and patterns.

After: AI sees how your team actually structures code, what conventions you follow, what trade-offs you’ve made. Suggestions are specific to your reality.

The quality shift: Fewer “that won’t work here” moments. More “that actually fits our architecture.”

From single-turn to multi-step workflows
#

Before: Every task is a new conversation. AI has no memory of what you’re working on or why.

After: AI can follow multi-step workflows that span files, systems, and contexts. It remembers the goal and carries it forward.

Example: “Analyze the performance metrics for the API, identify the slow endpoints, check the database queries for those endpoints, and suggest optimizations based on our actual schema.”

That’s four different context sources (metrics, API code, database, schema) orchestrated into one coherent workflow.

When to start building your own MCP servers
#

Once you’ve used MCP and see the value, you’ll spot the gaps. Systems specific to your company. Internal tools that don’t have public MCP servers. Workflows unique to your team.

That’s when you build.

The right first server to build
#

Your internal documentation. If you have Confluence, Notion, or internal wikis, an MCP server that exposes them as resources solves an immediate problem.

What it enables: Developers can ask AI questions about your internal systems and get answers sourced from your actual docs. No more hunting through wiki pages.

Technical complexity: Low. Resources are read-only, security is straightforward, and the value is immediate.

The second server: your APIs
#

Expose your internal API schemas and enable AI to understand how services connect.

What becomes possible: “Show me how to call the user service to update preferences” gets a response based on your actual API, not generic examples.

The integration pattern: Start with read-only schema exposure. Add safe test operations. Never expose production-write operations without explicit approval flows.

Building with the official SDKs
#

Official SDKs exist for TypeScript, Python, Java, Kotlin, C#, Go, PHP, Ruby, Rust, and Swift. Pick your stack and start.

The architecture is simple:

Expose resources through resources/list and resources/read
Declare tools through tools/list and handle calls through tools/call
Define prompts that guide AI behavior for your specific use cases

Use the MCP Inspector to test your server. Connect to it, browse resources, invoke tools, see what the AI sees. Essential for debugging.

Security patterns that matter
#

1. Start local, go remote carefully

Local servers (stdio transport) are simpler and more secure. They run on the developer’s machine with their permissions.

Remote servers (HTTP transport) enable team-wide access but require proper authentication, authorization, and audit logging.

2. Read-only first, mutations later

Resources are safe. Tools that modify data are not. Start with exposure, add write operations only when you have proper approval flows.

3. Never trust inputs

Validate everything. Use JSON Schema for tool parameters. Sanitize inputs. Assume the AI might be tricked into sending malicious requests.

4. Handle credentials properly

Environment variables for development. OS keychains for local desktop apps. Proper secret management for remote servers. Never in code, never in logs.

Why OpenAI and Google adopted this so fast
#

MCP launched in November 2024 from Anthropic. By March 2025, OpenAI adopted it. By April, Google announced support.

When competing AI companies agree on a standard in months, not years, pay attention.

The reason: Everyone faces the same integration problem. Claude needs to connect to databases. ChatGPT needs to connect to databases. Gemini needs to connect to databases.

The old approach: Build custom connectors for each AI tool and each data source. Multiplication of effort.

The MCP approach: Build one server that exposes your database through a standard protocol. Every MCP-compatible AI tool can use it immediately.

The ecosystem effect: As more tools adopt MCP, every MCP server you build becomes more valuable. As more servers exist, every AI tool that adopts MCP becomes more useful.

This is infrastructure-level network effects.

What this enables that wasn’t possible before
#

The real shift isn’t about making current work easier. It’s about making new patterns possible.

Contextual code review
#

AI that reviews code with full access to:

Your architecture decision records
Previous similar changes and their outcomes
Production metrics for affected services
Team conventions and style guides

This isn’t generic linting. It’s review that understands your actual system and suggests improvements based on what you’ve learned, not what’s theoretically best.

Predictive debugging
#

When an error occurs, AI with MCP access can:

Read the error logs from your monitoring system
Analyze the relevant code with full repository context
Check similar past incidents and their resolutions
Query the database state at the time of the error
Suggest fixes based on your actual patterns

From hours to minutes. The context gathering that used to take most of the debugging time happens automatically.

Architectural coherence
#

AI that can enforce architectural patterns by:

Seeing your actual service boundaries and dependencies
Understanding the intent behind your design decisions
Catching violations as they’re written, not in review
Suggesting alternatives that fit your established patterns

This moves from reactive to proactive. Instead of fixing architectural drift, you prevent it.

Knowledge continuity
#

When a developer leaves or moves teams, their context doesn’t disappear if it’s encoded in MCP servers. The AI has the same access to systems, docs, and patterns.

Onboarding acceleration: New developers get answers sourced from actual systems, not just wikis that might be outdated.

For managers: the strategic opportunity
#

If you’re leading a team or organization, MCP represents more than a technical standard. It’s a forcing function for better infrastructure.

The immediate productivity play
#

Week 1: Install Claude Desktop for your team. Add filesystem and Git MCP servers. Developers can now ask AI about your actual codebase.

Week 2-4: Add database MCP servers (read-only, development instances). Connect to internal documentation.

Month 2: Measure time saved on context gathering, debugging, and code review.

The ROI is quick and measurable. Developers spend less time hunting for context and more time solving problems.

The platform investment
#

MCP forces you to think about your systems as APIs. What should be exposed? What’s the right level of abstraction? What are the security boundaries?

This work pays dividends beyond AI. Better-defined interfaces, clearer boundaries, improved documentation. You get organizational clarity whether or not MCP becomes the dominant standard.

The competitive positioning
#

AI adoption is uneven across teams. The constraint isn’t model quality, it’s integration with real work.

Teams with good MCP infrastructure can use AI effectively. Teams without it are stuck with generic, context-free interactions.

This creates meaningful differentiation in productivity, quality, and velocity.

The talent development angle
#

Engineers who understand how to build, secure, and scale MCP integrations are developing valuable skills.

This is infrastructure-level knowledge that transfers across companies. It’s not framework-specific or company-specific. It’s fundamental to how AI connects to systems.

Investing in team education here compounds. These skills become more valuable as the ecosystem matures.

The broader pattern: context is infrastructure
#

MCP is part of a larger shift. AI isn’t just about better models. It’s about better connections between models and the systems where work happens.

We’re moving from:

Isolated AI interactions to connected workflows
Generic suggestions to context-specific guidance
Manual context gathering to automatic context access
Single-turn conversations to multi-step orchestration

This is the infrastructure layer for AI-native development. Just like REST APIs became infrastructure for web services, MCP is becoming infrastructure for AI integration.

The companies and teams that recognize this early and build the right connective tissue will have a sustained advantage.

What comes next
#

Near-term (Q4 2025):

MCP 1.0 spec release (November 25, 2025)
Wider IDE integration as standard feature
Improved tooling for building and testing servers
Enterprise adoption at scale

Medium-term (2026):

MCP becomes expected, not optional
Security and compliance frameworks mature
Performance optimizations and caching patterns
Vertical-specific server ecosystems emerge

Long-term trend: AI context shifts from “what you paste in the chat” to “what the AI has access to through proper integrations.”

The quality of AI assistance becomes proportional to the quality of your MCP infrastructure.

For developers: the career angle
#

What’s valuable right now:

Understanding how to use existing MCP servers effectively
Building servers for gaps in your team’s workflow
Implementing security patterns correctly
Designing integrations that scale

What becomes valuable:

Deep expertise in MCP architecture and best practices
Domain-specific integration knowledge (healthcare, finance, etc.)
Platform-level thinking about how AI connects to systems
Security and compliance for AI integrations

The skill combination that matters: Understanding both AI capabilities and production systems. How to give AI the right context without compromising security. How to design integrations that teams actually use.

This is infrastructure work. It’s less flashy than training models but more durable and more broadly applicable.

Start now, build as you go
#

If you’re a developer:

Install Claude Desktop this week
Add filesystem and Git servers to your workflow
Notice where you still need to manually provide context
Build MCP servers for those gaps
Share what you build with your team

If you’re a manager:

Set up MCP infrastructure for your team this month
Measure time saved on context gathering
Identify team-specific systems that need servers
Invest in building those integrations
Make MCP literacy part of onboarding

The best time to start was six months ago when MCP launched. The second best time is today.

The teams that move now will have compound advantages as the ecosystem matures. Not because they predicted the future, but because they built the infrastructure that makes AI actually useful for real work.

Get started:

The gap between AI demos and AI productivity is context. MCP is how you close it.

MCP · PiniShv

WordPress Just Let AI Agents Publish to 43% of the Web. Now What?

What it actually looks like #

Meanwhile, YouTube is going the other direction #

What’s actually happening here #

The SaaS connection #

Open WebUI Isn't a ChatGPT Clone. It's AI Infrastructure.

What Open WebUI actually is #

What it can actually do (beyond chat) #

The reality of running it in production #

Who’s behind it and why that matters #

The security conversation nobody wants to have #

Why teams and orgs actually adopt this #

How it compares to the incumbents #

How it compares to open-source alternatives #

What this actually means for engineering leaders #

Who should care about this #

Your AI Agents Are Flying Blind. Here's How to Fix That.

Two teams, same agents, wildly different results #

Where knowledge actually lives (and why that’s broken) #

The wrong way to fix this #

What actually works: a developer knowledge hub #

Git for authoring #

Semantic search for retrieval #

MCP for delivery #

The loop that makes it compound #

The AGENTS.md safety net #

Why nothing on the market solves this #

How to start (without boiling the ocean) #

The uncomfortable question #

Model Context Protocol: The Missing Connection Between AI and Your Real Work

The problem MCP solves #

What MCP actually does #

Understanding the architecture (if you’ve built APIs, you’ll get this) #

The three-layer architecture #

How it compares to other integration patterns #

The transport layer (how data moves) #

The protocol is simple (intentionally) #

Why this architecture works #

How to start using MCP today #

Step 1: Install an MCP-compatible client #

Step 2: Add your first MCP server #

Step 3: Connect to your databases #

Step 4: Add Git context #

Step 5: Connect to your tools #

What changes when AI has real context #

From manual context to automatic context #

From shallow answers to deep understanding #

From single-turn to multi-step workflows #

When to start building your own MCP servers #

The right first server to build #

The second server: your APIs #

Building with the official SDKs #

Security patterns that matter #

Why OpenAI and Google adopted this so fast #

What this enables that wasn’t possible before #

Contextual code review #

Predictive debugging #

Architectural coherence #

Knowledge continuity #

For managers: the strategic opportunity #

The immediate productivity play #

The platform investment #

The competitive positioning #

The talent development angle #

The broader pattern: context is infrastructure #

What comes next #

For developers: the career angle #

Start now, build as you go #