Our finance team had a workflow that touched three systems. They read data from one service, confirmed it in an external tool, then reconciled and checked it in the software we use for budgeting and tracking. None of it was hard. It was tedious, it had to be done for every employee, and it mattered to the business.

So the team described the workflow to Claude Code. What came back was a small web app that brings the three systems together on one page, and the team now uses it to run that workflow.

The interesting part is what that app doesn't contain. It has no login page and no API keys. It has no code that decides who may access the page, and no URL for any of the systems it reads. All of that lives in a platform we call Cove.

Cove is our internal app platform. Anyone at PolicyMe can connect a coding agent to it, describe the tool they need, and publish it for their team. Engineering owns the platform: who you are, what data you can reach, and the checks every app passes before it goes live. Teams own their Cove apps.

Figure 1 · Prompt to URL

Illustrative example

Claude Code

> Build an expense check that flags claims over policy for my team.

  1. create_appexpense-check
  2. write_app_file×3 files
  3. deploy_draftdraft link
  4. publish_draftlive link

Cove

identity
storage
connectors
publish checks
expense-check · restricted 3 files · no build step checks passed · private draft live · shared with Finance
about:blank/apps/expense-check/

no link yet

link shared with Finance

Expense check

Signed in as Raj
  • Taxi · $38OK
  • Hotel · $612Over policy
  • Team lunch · $96OK
no login form · no keys · no URLs

create_app. The agent registers the app over MCP. The person typing becomes its owner.

write_app_file. Plain HTML, CSS and JavaScript files go to Cove. What the agent writes is what the browser runs.

deploy_draft. Cove runs every check on every file, then serves a private draft link.

publish_draft. Exactly that draft goes live, and the link goes to the team.

A colleague opens it. They are already signed in. The app asks Cove who they are and never sees a password or a key.

1 / 5 · create_app 2 / 5 · write_app_file 3 / 5 · deploy_draft 4 / 5 · publish_draft 5 / 5 · colleague opens it
Figure 1. The agent talks only to Cove, and the viewer talks only to Cove.

Three panels in a row, joined by two links. Left: a Claude Code window where someone types "Build an expense check that flags claims over policy for my team.", with a log of four tool calls: create_app (expense-check), write_app_file (×3 files), deploy_draft (draft link) and publish_draft (live link). Middle: Cove, with identity, storage, connectors and publish checks, joined to Claude Code by an MCP link. Right: a browser, joined to Cove by a "signed in" link. The figure steps through five stages. 1, create_app: the agent registers the app over MCP, and the person typing becomes its owner; Cove shows expense-check · restricted. 2, write_app_file: three plain files (index.html, app.js, styles.css) go to Cove's storage, with no build step. 3, deploy_draft: Cove runs every check on every file, then serves a private draft link. 4, publish_draft: exactly that draft goes live, and the link goes to the team; Cove shows live · shared with Finance. 5, a colleague opens it: the browser shows /apps/expense-check/, the Expense check app signed in as Raj, listing Taxi · $38 OK, Hotel · $612 Over policy and Team lunch · $96 OK, with the note no login form · no keys · no URLs. The app asks Cove who the viewer is and never sees a password or a key.

Why we built it

We noticed people outside engineering building useful tools for their teams with AI. As those tools got more useful, they picked up production concerns without production infrastructure. Teams wanted access control. They wanted real data. And they wanted Claude Code to build integrations with the external services they use every day.

Real data is where the risk starts. To reach reporting data, a ticket board or an AI model, an app needs a credential. The quickest way for a coding agent to make the app work is to put that credential in the page. The key then ships to every visitor along with the HTML, and anyone who opens developer tools can read it.

A mock claims dashboard in a browser with developer tools open. Line 13 of app.js holds an API key in plain text, and a banner reads: Anyone who opens this page can read line 13.
Figure 2. How a key leaks. The agent writes code that calls the service straight from the page, so the credential ends up in the browser. An illustration, not a real app.

We're an insurance company, so we take security and privacy seriously. We also want to stay at the front of this technology and give everyone at PolicyMe access to the best tools. We didn't want to choose between those two goals.

So we started designing a platform for it, built around MCP so that any coding agent could publish to it. Along the way we read how Shopify built Quick and how Wealthsimple built Magic. Both confirmed a lot of what we had planned, and we borrowed from both.

We named it Cove. A cove is a calm, sheltered inlet, protected from the open sea. Apps run out on the open water, in the browser, where anything in the page can be read. The keys and the connections to our systems stay inside the cove, and an app asks for what it needs by name.

Slide titled The app never holds the key. Before: your app, out on the open sea, holds the key to SaaS apps, so the key is reachable from the water. With Cove: your app asks by name, and the key, the SaaS apps and the MCPs sit sheltered behind the curve of the cove.
Figure 3. The idea behind the name. Before Cove, the app holds the key and can leak it. With Cove, the app asks by name, and the key stays in the cove.

Secure and easy at the same time

One question shaped every design decision. If people who aren't engineers are going to build software with a coding agent, how do we make the secure way to ship it also the easy way? Nobody should have to file a ticket or learn our infrastructure to do the right thing.

That question gave us three rules:

  • A Cove app is plain HTML, CSS and JavaScript. There is no build step and no package.json. What the agent writes is what the browser runs.
  • An app only talks to Cove. Anything that needs a secret, an identity or a policy decision is a call into Cove through a small SDK.
  • Every app goes through the same security checks. Before anything goes live, Cove checks it against the security and compliance requirements we set for every Cove app, whoever wrote it.

How Cove fits together

Cove has four pieces, plus the security checks that sit in front of publishing.

Identity comes first. Cove sits behind our company identity provider and a zero-trust network layer. By the time someone sees the app gallery or opens an app, they are already signed in, and every Cove API checks who is calling on every request. That's why no app needs a login page. The app asks Cove who the viewer is and gets back a verified answer.

The Cove homepage: a gallery of published apps as cards, each with a name, description, owner, version, date and an Open button, with search and an owner filter above.
Figure 4. The Cove homepage. People land here already signed in, with every app they can open in one gallery.

The MCP server is how agents build. A person connects Claude Code or Cursor once and approves it in the browser. From then on the agent works through a few tools:

  • get_platform_context tells the agent the rules, the app templates and what the authorized user may use.
  • create_app and write_app_file create the app and write its files.
  • deploy_draft runs every check and serves a private draft.
  • publish_draft makes exactly that draft live.

There is no way to publish without a draft first.

Connect an agent: the Cove page where people connect their coding agent with one command and one browser approval.
Figure 5. The page where people connect their agent. One command, then one approval in the browser.

The SDK is how apps reach the platform. It is small on purpose:

javascript

const me = await cove.identity.me();                // the signed-in employee
await cove.kv.put('notes', 'q3', draft);            // stored for this person, in this app
const reply = await cove.connect('llm', path, opts); // a named connector, never a URL

Each person's storage is private to them in each app, so one viewer can never overwrite another's data. For spreadsheets, an app sends a row key and named fields, and Cove writes only the columns that connector allows. The app can't name a cell, so a bug in it can't overwrite the rest of the sheet. When an app throws an error in someone's browser, the SDK reports it to Cove. The owner's agent reads those errors through the MCP server and can fix the app before anyone files a bug.

Connectors are how apps reach data. An app never holds a URL or a credential for an internal system. It names a connector, such as our internal LLM gateway, BigQuery, Slack or Google Sheets. Cove checks that the viewer's role may use that connector, adds the credential on the server, applies a rate limit and writes an audit record.

Because an app can only talk to Cove, every connector call goes through one place. Each app declares the connectors it uses, so we can see what every app can reach, and who used it and when, without reading its code. That makes adding a connector a deliberate decision. A new connector starts closed. Before an admin grants it to a role, we talk through what data it exposes, who needs it and what could go wrong. We can also limit it to the paths and methods apps need, for example read-only access.

Bill Coder, a finance app on Cove, whose connect page reads connected by Cove. Nothing to set up here.
Figure 6. A finance app. Its connect page reads "connected by Cove. Nothing to set up here."

Security checks run before anything goes live. Every draft and every publish goes through the same checks, which make sure the app meets the security and compliance requirements we hold every Cove app to. Cove scans every file and refuses any app whose code sends requests to a host other than Cove. Font stylesheets such as Google Fonts are the only outside hosts allowed. Cove also refuses build tooling, checks JavaScript syntax, and checks that the author holds every connector the app declares. When a check fails, the error message names the fix, because the reader is usually a coding agent.

Access is set per app. An app is open to everyone or restricted to roles such as Finance. Admins manage the roles, which connectors each role may use, and which AI models are on offer. Because every capability goes through Cove, extending the platform means adding an SDK call, an MCP tool or a connector once, for every app.

Figure 7 · How the pieces connect

Hover or tab to a part

How the pieces connect Secure cloud workspace: we manage it, and control which sites and systems an agent can reach while it builds. SECURE CLOUD WORKSPACE Coding agent Claude Code or Cursor MCP Cove owned by Engineering MCP server: how agents build. get_platform_context, create_app, write_app_file, deploy_draft, publish_draft. MCP server how agents build Publish checks: every draft and every publish scans every file before anything goes live. publish checks App hosting: private drafts and live apps. Plain HTML, CSS and JavaScript. App hosting drafts · live apps Identity: every Cove API checks who is calling on every request. Apps ask Cove who the viewer is. Identity who is calling cove.* SDK and platform API: identity, per-app storage, app metadata, safe spreadsheet writes, error reports and connector calls. SDK + platform API apps call Cove Connectors: Cove checks the viewer's role, adds the credential on the server, applies a rate limit and writes an audit record. Connectors keys stay here Apps hold no URLs, no keys and no sign-in code. Company identity provider and a zero-trust network layer. People are signed in before they reach Cove. identity provider + zero-trust network An employee's browser opening a Cove app. Employee's browser opens an app Internal systems. Only connectors reach them, never an app. INTERNAL SYSTEMS LLM gateway BigQuery Slack Sheets How the pieces connect SECURE CLOUD WORKSPACE Coding agent Claude Code or Cursor Employee's browser opens an app identity provider + zero-trust network Cove owned by Engineering MCP MCP server how agents build publish checks App hosting drafts · live apps Identity who is calling SDK + platform API apps call Cove Connectors keys stay here INTERNAL SYSTEMS LLM gateway BigQuery Slack Sheets
Figure 7. Nothing in an app reaches our internal systems directly. The agent and the browser both stop at Cove.

Left: a coding agent in a secure cloud workspace, connected to Cove's MCP server over MCP. Right: an employee's browser behind the identity provider and zero-trust network, reaching Cove's identity layer. Middle: Cove, with an MCP server, identity, app hosting, an SDK and platform API, and connectors. Publish checks sit on the path from the MCP server into app hosting. Apps call the SDK and platform API, which uses connectors. Connectors fan out to internal systems: the LLM gateway, BigQuery, Slack and Sheets. Nothing in an app reaches those systems directly.

One more layer sits before Cove. People who build with coding agents work in secure cloud workspaces that we manage, so we also control which sites and systems an agent can reach, at the host and network level, while it builds.

What people have built

Animation scrolling down the Cove app gallery, past cards for apps such as expense-check, tracking-plan-explorer, billcoder, diagram-desk and break-room, some marked restricted, to the page controls at the bottom.
Figure 8. Scrolling the gallery. Each card shows the app, its owner, its version and whether it is restricted.

Teams across the company have published apps on Cove. A few we like:

  • Bill Coder helps finance code and review bills against the accounting system, through Cove's connectors.
  • Tracking Plan Explorer lets people search our product analytics tracking plan, including event severity and events we don't track yet.
  • Diagram Desk is a whiteboard for quick architecture and workflow diagrams.
  • Break Room is a set of short daily games for a remote-first team.
Tracking Plan Explorer: a searchable view of the product analytics tracking plan.
Figure 9. Tracking Plan Explorer.
Diagram Desk: a whiteboard app for quick architecture and workflow diagrams.
Figure 10. Diagram Desk.

None of these apps has a login page, a stored key or its own idea of who may use it.

Small on purpose

Cove runs as one container service on AWS Fargate. Published app files live in S3, and app records, storage and the audit log live in Postgres. The security checks run in a Lambda service when an agent creates a draft. Because apps don't need build tools, we don't need a separate build system.

The no-build rule is what keeps it that small. Every app is plain HTML, CSS and JavaScript, so publishing is a scan and a copy to S3. There are no builds to run, no dependencies to patch and no servers per app to keep alive. That keeps Cove cheap to run, and it doesn't need a dedicated team to maintain it.

What's next

Next is Cove Docs. Teams already write design docs, incident reviews and explainers with Claude. Today those end up as a Claude artifact in one person's account, or as an HTML file copied by hand to an internal site with no access control per document. Cove Docs gives each document a link that opens only for the people it's shared with, with comments pinned to the text that the owner, or their agent, can answer.

HTML docs run in a sandbox with a strict Content-Security-Policy, so a doc's scripts can't act as the reader or send data anywhere. Our documents stay on our own infrastructure, with every publish, share and open audited. It also lets us retire an older internal site that only developers could publish to, so all our web explainers and artifacts live in Cove under the same guidelines and security controls as apps.

We also plan to write more about the infrastructure underneath Cove, and about how AI is changing the way we work so we can build better products for our clients.

Thanks to the teams at Shopify and Wealthsimple for writing up Quick and Magic in the open. Their write-ups shaped our design and gave us confidence in it. Quick showed that plain HTML with no build step, backed by a shared set of platform APIs, is enough for most internal tools. Magic showed that an agent can publish over MCP from inside the conversation, and that sign-in can come from the identity layer a company already runs.

Credits

Abraham Nnaji
Senior Software Engineer
Gabriel Lee
Staff Engineer

Come build with us

We're hiring engineers who care about secure, well-built software. See what's open on the PolicyMe engineering team.

See open roles