Bring Your Own AI Provider: Use OpenAI, Claude, Gemini or Bedrock With Archyl

The first time I demoed Archyl to a Fortune 500 architecture team, the conversation went really well — until minute 23.

"This is great. Genuinely. But our security team won't let us send code through your AI. We have an Anthropic contract through Bedrock. Everything has to go through that endpoint."

I'd heard variations of the same line a dozen times by then. Different companies, different providers, same wall:

"We already pay Azure OpenAI." "Our data has to stay in eu-central-1." "Legal signed off on Mistral, not on whatever you're using." "Can we use our own GitHub Models contract? It's bundled with the seats we already bought."

Until today, the answer was always: not yet.

Today it is yet. Every Archyl AI feature can now be routed through your AI provider, with your API key, on your contract. Pick from OpenAI, Anthropic (Claude), Google (Gemini), AWS Bedrock, or any OpenAI-compatible endpoint — and Archyl quota limits stop applying because you're paying the provider directly.

Let me explain what changed, why it's a bigger deal than it sounds, and how to turn it on.

Why this matters more than "we added a config field"

Archyl is built around AI. Architecture discovery reads your repository and generates a C4 model. ADR parsing turns markdown into structured decisions. The chat assistant answers questions across your projects. Managed agents run multi-step tasks against your codebase. Insights surface architecture problems before they become incidents.

For two years, all of that ran on a model I picked, paid for by an OpenAI key I owned. Most customers were perfectly happy with that — it's one less vendor relationship to manage. But "most" is not "all," and the customers I was losing were the ones I most wanted: large engineering organizations with serious architecture practices and real budgets.

What was blocking them wasn't price. It was three other things:

  1. Data residency. Their security team had signed off on a specific vendor in a specific region. My provider wasn't on the list, and adding a vendor takes months.
  2. Existing contracts. They'd already negotiated enterprise pricing with Anthropic, Azure OpenAI, AWS Bedrock, or Mistral. Paying me to mark up a different provider's tokens didn't make sense to procurement.
  3. Compliance. GDPR, SOC 2, HIPAA, financial regulators. The audit trail has to land in their tenant, not mine.

The fix had to give them three things at once: their key, their model, and no double-billing for AI usage. That's exactly what BYO Provider does.

What you can wire up

Five providers shipped today. Four are first-class native integrations; one is a generic shim that covers a long tail of compatible endpoints with one config.

OpenAI — api.openai.com directly with your own key. Default model is gpt-5.4-mini, but you can override it per feature.

Anthropic (Claude) — the Messages API, streaming included. Default claude-sonnet-4-6. This is the one most enterprise teams seem to land on.

Google (Gemini) — the Generative Language API with native JSON mode. Default gemini-2.0-flash.

AWS Bedrock — the Converse API, which is unified across every Bedrock-hosted model. So one integration covers Anthropic Claude on Bedrock, Mistral, Llama, Titan, Cohere — whatever your account has enabled. You provide AWS credentials in <access_key_id>:<secret_access_key> form (with optional STS session token), plus your region.

OpenAI-compatible (everything else) — one adapter, one base URL field. This single integration covers Azure OpenAI, GitHub Models, OpenRouter, Mistral La Plateforme, Groq, Together AI, Fireworks, DeepInfra, vLLM, llama.cpp, and roughly any other endpoint that speaks the OpenAI Chat Completions wire format. You point at the base URL, paste a key, you're done.

That last one was the most fun to design. Every six months a new "we're 30% cheaper than OpenAI for the same quality" provider shows up — and they all converge on the OpenAI wire format precisely because everyone else integrated against it. Treating that whole long tail as one provider with a configurable base URL means we get those new endpoints for free, and you don't have to wait for me to add them.

A model per feature, not just a provider

Routing every Archyl feature through gpt-5.4-mini is a choice I made for the platform. It's not the right choice for every customer. Discovery is token-heavy and benefits from a strong reasoning model. Chat needs streaming feel. Managed agents are essentially Claude-shaped. Doc title generation can run on whatever's cheapest.

So when you turn on BYO Provider, you don't just pick one model — you pick a default and then override per feature:

  • Chat
  • Discovery (and its three sub-phases: structure, refinement, file analysis)
  • ADR parsing
  • Doc title generation
  • Insights
  • Managed agents

Leave any field blank and it falls back to the provider's sensible default. Fill it in with the exact model identifier — claude-opus-4-5, gpt-4o, mistral-large-latest, anthropic.claude-sonnet-4-20250514-v1:0, whatever — and Archyl passes it straight through.

This matters more than it sounds. One customer wants Claude Sonnet for chat (low latency) and Claude Opus for discovery (reasoning quality). Another wants Bedrock Llama for everything except managed agents, which they want on Anthropic direct. Both are now a couple of dropdowns away from their ideal setup.

What happens to your quota

This is the part procurement actually cares about. Archyl's free and paid tiers each include a monthly quota of AI discovery operations, chat queries, and managed agent runs. That quota exists to cover my OpenAI bill.

When BYO Provider is enabled, all of that quota enforcement is skipped. Your provider invoices you directly for usage. Archyl no longer counts against your monthly cap because you're not consuming Archyl's pooled AI spend.

In practical terms: a Business-tier organization with BYO Provider on gets unlimited discovery, unlimited chat, unlimited agent runs — capped only by what you're willing to spend with Anthropic or AWS. The Archyl seat price covers the platform; you cover the tokens.

For organizations that want to stay on the platform-managed model, nothing changes. The toggle is opt-in, off by default, and reversible in one click.

Turning it on

Settings → AI tab. Five steps, maybe two minutes:

  1. Pick your provider.
  2. Paste your API key. (For Bedrock: <access_key_id>:<secret_access_key> plus the AWS region.)
  3. Optionally override per-feature models. Leave blank to use the provider default.
  4. Hit Test connection — Archyl pings your provider with a tiny completion to confirm credentials work before you commit.
  5. Toggle Enable and Save.

That's it. The next AI request from anyone in the organization — discovery, chat, agent run, ADR import — flows through your provider, on your model, with your key.

API keys are encrypted at rest using AES-256-GCM with the platform's encryption key, never echoed back in API responses (the UI shows •••••••• and a "key is stored" indicator), and only decrypted in-process when a request needs to be made. Removing the configuration wipes the key.

Only organization admins can configure this. Members will see AI features continue to work transparently — the routing is invisible to them.

What's next

A few things are already on the roadmap based on early customer conversations:

  • Bedrock Provisioned Throughput for organizations with reserved capacity contracts.
  • Per-project provider override, so a team running a sensitive project can route only that project through a specific endpoint while the rest of the organization uses the default.
  • Bring-your-own-key audit log, surfacing exactly which feature called which provider with which model, for compliance teams that need to demonstrate it.

If any of those would unblock you — or if there's a sixth provider I should add — I'd love to hear about it. Reply to this post, hit me on the in-app chat, or book 20 minutes.

If you've been waiting for "we already use {your AI provider}" to stop being a blocker for adopting Archyl, this is the release. Spin up an organization, drop in your key, and route every AI feature through the contract you already have.

Your architecture, your provider, your key. The product stays the same — only the bill moves.