How I Built an AI Assistant That Keeps Working When Its Model Provider Fails

It is 9am on a Monday and the automation that ran perfectly last week is throwing errors. Your AI provider is rate-limiting you. Or its newest model update changed the behavior you relied on. Or the model you hardcoded was retired overnight. You have two choices: wait it out, or call a developer and pay to rewire everything. Neither one is good.

That is the problem I set out to kill in the latest upgrade to Seepient, my AI assistant for growing businesses. If you have been following this build log, you know the last release made approvals survive a crash. This one makes the whole model supply chain behind the assistant survivable too.

The short version. Seepient used to be wired to one model from one provider, the way most AI tools are. Now you choose the model for each job and your choice is honored, the work falls over to your backup model automatically when a provider fails, new models work the day they ship, conversations stay clean even with thinking models, images come out as real files, credentials sit in your system's keychain, and the bill shows the true cost. Here is how it all fits together.

Choose your models, and they stay chosen

The first thing I changed is the oldest assumption in the product: that a model is a fixed part of the software. Until this release, when you picked a model it was wired in as a permanent dependency. Pick it, forget it, hope it never breaks. Think of it as hiring one person and hoping they never get sick, never learn anything new, and charge you the same rate for every task no matter how hard it is. A real business would not run that way, so I stopped building Seepient that way.

• Your choice is honored. When you assign a model to a task, Seepient uses that exact model. It does not quietly switch to a default because a provider looks slow. What you asked for is what runs.
• Task-specific assignments. You can set one model for planning, another for coding, another for writing, and another for image generation. You can also set the effort level for a task: standard, complex, or efficient. A quick question goes to a fast, cheap model. A big planning job goes to your strongest one. You stop paying flagship prices for trivial work.
• Broad model support. Seepient works with the major providers, with custom endpoints that speak the standard API format, and with locally hosted open-source models like Ollama. If it can talk to the model, the assistant can use it.
• One engine everywhere. The command line, the chat interface, the built-in server, and the programming interface all run on the same provider engine now. Before, each surface could drift and behave differently with the same models. Now there is one behavior, tested once, shared everywhere.

When a provider fails, the work moves on its own

This is the change I am most proud of, because it is the one that saves a real business day. An outage no longer stops your work.

• Automatic fallbacks. If a provider is down, rate-limited, or having a bad hour, Seepient routes the request to the next provider in your fallback chain. The assistant's work continues and you do not have to notice.
• Cool-downs, not hammering. A provider that just failed gets a rest period, and the waiting time grows each time it fails again. The whole fallback sequence runs inside a strict four-minute budget, so a broken provider can never stall your work forever.
• Recovery mid-answer. If a connection drops while the assistant is replying, it recovers without replaying a half-finished response back to you.

The goal is not to make every provider work all the time. It is to make sure no single provider can stop your work.

Cleaner conversations and better images

A model that thinks before it answers used to clutter the chat. Each step of its reasoning arrived as its own message, so a simple question could produce a wall of fragments. Now the reasoning, the text, and any actions combine into one clean turn per request. Nothing is duplicated, nothing is scattered.

The same care went into streaming. Real-time text and thinking streams render smoothly, and if the connection drops there are no overlapping blocks and no duplicate outputs. When you stop a request, it actually stops. Processing and network activity halt immediately instead of running on in the background.

Image generation got the same upgrade. Seepient now supports the latest generation of image models, with aspect ratios, style presets, and quality settings. Generate several images and each one comes back as its own full-resolution file in your workspace, not a text summary. If a model cannot do something, like editing an image when it only supports generation, Seepient tells you before any request goes out and before any money is spent.

One place to manage every provider

The new engine comes with a single management view. You can see all your providers and accounts, test them, and change model assignments from one screen. Models are discovered automatically: Seepient asks each provider what is actually available right now, so a model released today can be used today, with no software update. Feature details like image support or reasoning modes come along with the discovery. When you upgrade, your existing API keys, custom model assignments, and preferences carry over automatically, so nothing has to be set up twice.

Security and cost control

Two things a business owner should never have to worry about are stolen credentials and surprise bills. I used this upgrade to close both doors.

• Credentials in your keychain. API keys and tokens are stored in your system's native keychain, the same secure store your computer uses for its own passwords. They are never written into plain files.
• No secrets in logs. Keys and tokens never appear in logs, error messages, or history. If something breaks, the error tells you what happened without leaking what you typed.
• Safe network connections. One classic attack on AI tools is to trick the tool into calling an address inside a private network, where cloud credentials live. Seepient rejects those destinations outright and re-checks every step of the way, even after a redirect. If you run a private endpoint, you can allow it explicitly for that provider.
• A record that cannot be quietly changed. Every AI call is written to an audit log that only your account can add to. Each entry is saved to disk before the next one is written. If you ever need to know what the assistant did, when, and with which model, the record is there and it is complete.
• Honest cost tracking. The bill used to show input and output tokens and little else. Now Seepient tracks four numbers per request: input, output, cached tokens the provider has already seen, and reasoning tokens, the work a model does in its own head before answering. Prices come from the provider's live rate card, so the dollar figure you see is what you will actually be charged. Reasoning tokens are often the hidden part of an AI invoice. Now you see them before you approve the spend, not at the end of the month.

Where it nearly broke

This release was 54 commits, with four rounds of fixes in the final push. Routing a request to the right model was the easy part. Everything around it was the hard part:

• Tests that lied. Early fixes leaked credentials between tests, so a passing test suite could be hiding real bugs. Separating the test environment surfaced several.
• Redirects that slipped past the guard. My first network check looked at the destination, but a redirect could get around it. The fix re-checks every hop along the way.
• Files that raced. Two parts of the system writing configuration at the same moment could corrupt it. The fix was a lock with self-healing: if a crashed process leaves a stale lock, the system recovers on its own.
• Interfaces that drifted. The web interface and the command line behaved differently with the same models. Making them match exactly, including how a dropped connection is handled, took real time.
• Requests that hung. A stuck request could run forever. Now a watchdog aborts it inside the budget.

None of these show up in a demo. All of them would have bitten a real business at the worst possible moment, which is exactly why I keep shipping this series as build logs.

What I would do differently

I would build the provider layer as the foundation of the product, not as a migration. Seepient started with a simple hardcoded setup because that is what a prototype needs. By the time the redesign was justified, I was rewriting the whole stack underneath a working product, with eight cleanup phases just to remove the old paths safely. If I started today, the routing, the cost accounting, and the failover would be the first layer, not the fourth. The feature work would have been the same. The archaeology would not.

What this means for your business

Seepient no longer depends on any single model provider, any single model, or any single pricing table. This is the release that made me comfortable telling a business to run its workflows on this assistant.

If your automation stops whenever a provider has a bad morning, that is a design problem, not bad luck. Book a call and let's look at how your workflows are wired before the next outage finds the weak spot.