Skip to content
Vincent's Notes
Go back
3 min read

I Want the Model, Not the Shell

By Vincent Yang

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.

I Want the Model, Not the Shell
https://missuo.me/posts/why-openbuddy/
Published at
August 6, 2026
ShareShare this post on WhatsappShare this post on FacebookShare this post on XShare this post on TelegramShare this post on PinterestShare this post via email

Comments 0

Finished reading? Leave a word.