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 an executive 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.

If you’ve read the famous MIT report on AI in business, you’ll remember one of its main findings: AI agent pilots are twice as successful when companies partner with an external team versus trying to build everything internally. Not surprising: 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.

There’s a reason “The GenAI Divide” exists.

Why We Started Arcten

Michael and I have been building agents since GPT first launched. One thing we learned early: 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 (then called “Max AI”). It was much closer to what a copilot should be: something that can actually take action inside the product.

It was obvious to us that every app should have something as capable as Cursor—without a six-month build-out.

So we built Arcten.

What Arcten Does (Without the Buzzwords)

This part will sound like an ad, because it is.

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

Arcten 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 ~five 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, Arcten scales the same way.
Guillermo Rauch once described Vercel as “simple and scalable” in a way developers actually feel. We’re aiming for that same spirit.

Early Momentum

We soft-launched a short post on YC’s internal forum (Bookface) and the response caught us off guard. A wave of inbound. Multiple teams already live. And these are some of the most product-aggressive startups in each YC batch.

The pattern is obvious:

Teams that ship faster end up with better products.
Copilots accelerate both.

If You Want a Copilot That Actually Does Things

I’d be a terrible founder if I didn’t plug us at least once:

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