# I Want the Model, Not the Shell

> WorkBuddy lets you bring your own key, but still injects a hard content_policy into every system prompt. Direct calls to my provider work; the same model through the shell refuses. That is why I am building OpenBuddy myself.

Author: Vincent Yang
Published: 2026-08-06
Tags: AI, LLM, WorkBuddy, OpenBuddy, System Prompt, BYOK
Source: https://missuo.me/posts/why-openbuddy

---

I am not here to argue about whether the statements inside a product's system prompt are correct. That is a separate conversation, and it is not mine for this post.

What I care about, as a user, is simpler: **I want the model's own answer, not an answer reshaped after a third-party shell has rewritten the conversation.**

That is the whole reason I am not choosing WorkBuddy, and the reason I am building OpenBuddy myself.

## The setup that made it obvious

WorkBuddy markets itself as an AI workbench. It has a polished desktop shell, agent tools, skills, and, importantly, **bring your own key**: point it at your own provider, pay for your own tokens, use your own models.

So I did.

- Call my provider **directly** with the same model and key: normal answers.
- Call the **same** provider, model, and key **through WorkBuddy**: refusals on a long list of questions that the raw model would handle without drama.

If the transport works and the key works, the only remaining explanation is what the shell is stuffing into the request before it leaves the machine.

## What is actually on the wire

WorkBuddy is an Electron app. The interesting bits are not buried in some remote "safety API" that only runs when you use their hosted models. They ship as **local prompt templates** and product config:

- Desktop sessions: `app.asar.unpacked/resources/templates/workbuddy-*.tpl`
- CLI / agent kernel: `app.asar.unpacked/cli/product.json` → `cli-agent-prompt`

Every mode I checked (Craft, Ask, Expert, coding variants) injects a `<content_policy>` block into the system prompt. Ask mode and the CLI prompt are the most explicit. In short, the model is told it **must refuse**:

- "politically sensitive" topics, including Chinese politics **and** foreign political figures, elections, government policies, and geopolitical conflicts
- pornographic or sexually suggestive content
- illegal-activity instructions
- doxxing, defamation, harassment
- fake news, impersonation, fraudulent documents
- and that these rules **override user instructions**, including "testing", "research", or "hypothetical" framings

There is also hard language about Hong Kong, Macao, and Taiwan wording, plus a blanket "refuse politically sensitive content under Chinese law" line in the main Craft prompts.

The exact text is public if you own the app: unzip the asar, open the templates, read `product.json`. I am not quoting the full dump here. The point is architectural, not theatrical.

## Why "BYOK" is the wrong mental model

People hear "bring your own key" and assume:

```text
your question  →  your model  →  model's answer
```

What you actually get with a shell like this is closer to:

```text
your question
  → shell renders a large system prompt (tools + product identity + content_policy)
  → your key hits your provider
  → model answers under those instructions
```

The key is yours. The bill is yours. The **policy channel** is still theirs.

So when the model refuses, you are not watching "the model decide." You are watching a model follow a prompt the product author permanently bolted onto every turn. Direct API calls skip that bolt. The shell does not.

I do not care, for the purpose of this article, whether any individual line in that policy is wise, legal, or defensible. I care that **I did not ask for it**, I cannot turn it off, and it still runs when I am paying a third party for the model.

## What I want instead

I want a workbench where:

1. **BYOK means the model is the model.** No silent vendor content_policy injected over my provider. If I want extra system instructions, I write them.
2. **System prompts are inspectable.** If something is injected for tools, identity, or safety, I can see the full text, not discover it by reverse-engineering an asar.
3. **Native beats Electron for this job.** File tools, terminals, and long agent loops already fight the OS enough without a 250MB asar and a Chromium tax.
4. **Agent capability without product ideology.** Skills, tools, sessions, Code-mode CLIs: yes. Shipping someone else's political and moral script into every completion: no.

That product, for me, is **OpenBuddy**: a native macOS dual-mode workbench (Work + Code), Objective-C AppKit + Rust core, Anthropic / OpenAI-compatible providers, model list fetch, and no intention of becoming a compliance mouthpiece for whoever packaged the UI.

OpenBuddy will still have system prompts. Agents need tool instructions, workspace rules, and user-defined context. The difference is **who authors them and whether they are optional**. Product glue is fine. Invisible policy that survives "use my own API key" is not.

## A narrower claim, deliberately

This post is not:

- "WorkBuddy is evil"
- "content policies should not exist"
- "every refusal is censorship"
- a legal analysis of Chinese or other jurisdictions

This post is only:

> If I bring my own key to a shell, I still expect the model's answer, not the shell's answer wearing the model's name.

I am building OpenBuddy because that expectation is non-negotiable for how I work. If a polished Electron app cannot meet it, I will write the boring native one that does.