← Back to blog

Copilots: The Silent Shift

Copilots are becoming the new interface for software, but most teams can't build reliable, production-ready agents on their own. Mantl handles the hard parts — context, actions, guardrails, infra, and scale — so teams can ship a real, action-taking copilot fast.

Alexander Jacobsen·March 16, 2026·5 min read

Copilots Are Quietly Taking Over Software

If you've heard of a tiny startup called Cursor — or even GitHub Copilot — you already know the basic idea of a copilot.

But let's define it properly.

A copilot is an AI agent that lives inside your app, understands context, remembers what's happening, and can carry out real actions (including multi-step workflows) on behalf of the user. For years, this felt like a gimmick: a fun demo, not something you'd actually deploy in a production-grade application.

Then Cursor arrived. Its “coding copilot” showed what it looks like when this model actually works: an agent that lives inside your editor, sees your code, writes code back, and executes commands. Once you use a system like that, old interfaces instantly feel slow.

Enterprises See the Same

Every major software company is building its own take:

  • Microsoft → 365 Copilot
  • Salesforce → Agentforce
  • SAP → Joule

They're not doing this because it makes for nicer landing pages. They're doing it because user expectations have changed.

Users Don't Want Click Mazes Anymore

I recently spoke with someone at a company doing over $100M ARR. We talked about one workflow in their app that takes 50 clicks to complete. And this wasn't some rare edge-case workflow — it was a normal one.

This is the real problem across enterprise software: huge platforms packed with features, but actually using those features is a slog.

Modern users want something different:

  • Tell the app what you want.
  • Let the app handle the workflow.
  • No memorizing menu paths. No dashboard treasure hunts. Just intent → outcome.

A good copilot makes this feel natural rather than forced.

Why Most Teams Fail to Ship a Real Copilot

Here's the part people underestimate: adding a copilot is not “just write a prompt.”

A real production agent needs:

  • Deep context access
  • Reliable function calls and workflow execution
  • Retrieval that actually scales
  • Safety and guardrails
  • Human-in-the-loop review paths
  • Debugging tools and session replays
  • Continuous improvement loops

Most teams don't have the experience (or the time) to build agent systems that actually work. And this isn't just opinion — it's backed by data.

Writing scalable, reliable agents demands a very particular skillset — context engineering, prompt scaffolding, agent memory design, recovery strategies, and a deep understanding of model behavior at scale. It also requires production-grade agent infrastructure: real-time streaming pipelines, high-throughput orchestration, fault-tolerant state management, and routing layers that can dynamically select the right LLMs or tools based on cost, latency, and quality.

Add to that the challenges of safely coordinating thousands of concurrent agent executions, meeting strict SLAs, and supporting large numbers of daily active users. These are capabilities most enterprise teams simply don't have in-house.

Why We Started Mantl

One thing I learned early building agents: most teams are only getting maybe 50% of what today's foundation models can actually do.

A few examples stuck with me:

  • I tried AWS's provisioning agent. Instead of doing anything, it dumped links to documentation. I didn't ask for more docs — I wanted it to set up the instance (and ask for confirmation when needed).
  • I tried PostHog's AI. It was much closer to what a copilot should be: something that can actually take action inside the product.

It was obvious to me that every app should have something as capable as Cursor — without a months-long build-out.

So I built Mantl.

What Mantl Does

We're opinionated about how copilots should work, and that's why teams can ship functional agents with us instead of toy demos.

Mantl handles the hard pieces:

  • Index your knowledge sources (whether you have 10 docs or 10 million)
  • Connect to MCP and your existing function workflows
  • Run everything on our edge runtime for speed and reliability
  • Ship a real copilot in a few lines of code

Once you're in production, you automatically get:

  • Guardrails
  • Human-in-the-loop flows
  • Session replays
  • Continuous self-improvement pipelines

Whether you have 10 daily active users or 1 million, Mantl scales the same way.

If You Want a Copilot That Actually Does Things

If you want a copilot that actually takes action inside your app — and not just chat — book a demo.