I was experimenting with AI-assisted coding across several isolated workspaces. The setup could run tasks, but I kept running into the same issue: the part that chose a model, the part that executed code, and the part that showed me what had happened were all too tightly connected.
When a provider changed, I wanted the rest of the workflow to stay understandable. When a sandbox failed, I wanted to know whether the problem was the model request, the route, the runtime or the task itself. That was the reason for ModelBridge — a separate routing and management layer I could work on independently.
The starting point
The original setup used a multi-sandbox workflow: an agent workspace, a code-execution workspace and a provider-facing path, coordinated around tasks written in a structured format. It worked well enough to be useful, but it also exposed the friction that appears when a local experiment grows beyond a few commands.
My first goal wasn't to build another large AI framework. It was smaller: keep model access replaceable, give the surrounding workflow a stable interface, and make the current state visible without reading through scattered terminal output.
What ModelBridge does
ModelBridge started as a lightweight, multi-provider model router. Its job was to give the task runner one place to send requests, while the configured provider could change underneath. An OpenAI-compatible /v1/chat/completions API shape helped keep the calling side predictable.
Over time, I worked on routing rules, provider selection, health checks and an API/control layer. The intention was to avoid having to rewrite the agent workflow every time I tried a different model endpoint.
Architecture sketch of the experiment. Provider inference and sandbox execution are different responsibilities; arrows simplify the task orchestration.
This isn't a claim that I created an NVIDIA model, trained a foundation model or built the OpenShell runtime. ModelBridge is the independent integration layer. The underlying models belong to their providers, and OpenShell is a separate open-source project.
Where OpenShell fits
For sandboxed execution, my local workflow used NVIDIA OpenShell. In the environment I documented, OpenShell ran through WSL Ubuntu on a Windows host. It provided the external runtime and sandbox operations that the higher-level tools interacted with.
That distinction matters. A model router is concerned with requests, providers and responses. A sandbox runtime is concerned with where work runs and which operations are available there. Connecting the two was the integration work; neither component replaces the other.
The experiments referenced an OpenShell 0.0.36 environment. OpenShell continues to change, so I would not describe a local integration that worked against that version as automatically compatible with later releases.
Implementation boundary
My code operated around OpenShell CLI/runtime interfaces. Any real security guarantee depends on the specific runtime version, policies, host setup and deployment configuration. Using an isolated workspace does not remove every risk.
Why I kept a CLI and a control surface
The next problem was operational. I could run commands in a terminal, but checking a task across several sandboxes meant repeatedly switching context. I developed tooling around common operations such as runtime inspection, sandbox listing and execution, provider configuration and task status.
I also worked on a browser-based control surface. The interface wasn't supposed to become a second, unrelated backend. The aim was for the CLI and the UI to expose the same underlying operations, with error messages and state that meant the same thing in both places.
As the backend grew, I began breaking the control logic into smaller modules for gateway, sandbox, provider, policy and related operations. That was partly a maintenance decision: adding another command should not mean editing one enormous file and hoping the rest of the system still behaves.
What I actually tested
My development checkpoints included automated tests around command dispatch, routing, compatibility behavior and backend actions, alongside hands-on checks against the local OpenShell environment. I also used live runtime and sandbox checks rather than treating a green unit-test run as proof that all external services were available.
There are test counts from individual development phases, but I have deliberately left them out of this public note. Without a linked commit, test log and dependency versions, those numbers would say less than they appear to.
The useful outcome for me was practical: there was a clearer separation between model access, task orchestration, runtime execution and operator visibility.
What it didn't solve
Separating components made the workflow easier to reason about, but didn't turn a local development system into a production platform overnight. A public service would still need careful work around authentication, secrets, concurrency, timeouts, rate limits, failure recovery and compatibility across runtime versions.
There is another maintenance cost, too. Every integration has to track upstream behavior. An implementation built against one version of an external CLI can break as commands, flags or APIs evolve. I would rather document that boundary clearly than advertise vague "supports everything" compatibility.
That's why I treat this as an engineering record, not an unconditional release announcement. It documents what I built and why. It doesn't imply that a public installer, managed service or supported compatibility matrix is available from this page.
Credit, ownership and licensing
ModelBridge and the surrounding management work are independent projects by Baishalya Roul. NVIDIA OpenShell is a third-party project used in the experiments. I am not presenting this work as an NVIDIA product, collaboration, certification or endorsement.
NVIDIA OpenShell is published under Apache License 2.0. That license generally allows use, modification and redistribution of the covered code subject to conditions, including preserving required copyright and license information, marking modified files, and carrying applicable NOTICE attributions. It does not grant a general right to use the NVIDIA brand as my own.
If I publish a binary or source distribution that incorporates third-party code, I need to review the actual files, dependencies, licenses and notices included in that distribution first. This article, by itself, isn't a software distribution or a claim that the entire project has been license-audited.
Independent project disclosure
NVIDIA and OpenShell are referenced only to identify the third-party technology involved. NVIDIA does not sponsor, maintain or endorse ModelBridge or this website. Project source and installer links are intentionally not offered here until a separately reviewed public release is ready.
For my own work, the bigger lesson was simple: making two tools talk to each other is only the beginning. The part worth maintaining is the contract between them, the visibility when something fails, and the discipline to say exactly which setup was tested.
