Kubrick Studio: The Cheapest Way to Run AI Agents? A Real-World Test vs. Higgsfield

Many developers connect their AI agents to Higgsfield via the MCP protocol to access various generative models — a common approach in the industry. But an open-source project called Kubrick Studio offers a different path: a cheaper, or even free, way to let agents drive image and video generation. This article breaks down the tool's core design, how to connect models, and its cost advantages over Higgsfield.

Core Positioning: Open Source + Multi-Model Integration

Kubrick Studio is an open-source application — the author repeatedly encourages viewers to star it on GitHub to support ongoing development. Its core capability is using a large language model (LLM) as the "brain" for three types of tasks: rewriting prompts, describing images, and driving agents to execute tool calls.

The key design choice here is that all language model connections are centralized under "remote → language models" — a single entry point supporting five connection options. Rather than locking you into a single vendor, it integrates Deep Infra, OpenRouter, Ollama, self-hosted compatible endpoints, and more, letting users switch freely based on budget and privacy needs. This "connection layer abstraction" is exactly what enables it to compete with Higgsfield.

MCP (Model Context Protocol) is an open protocol released by Anthropic in late 2024, designed to provide AI agents with a standardized tool-calling interface. It works like a "USB port" for AI — as long as both client and server implement the protocol, agents can call filesystems, databases, external APIs, and other tools in a unified way, without writing custom integrations for each service. Higgsfield is a commercial platform focused on AI video generation, offering hosted access to multiple video models, but charges per generation — costs that add up quickly at scale. Kubrick Studio also supports the MCP protocol, meaning any agent already integrated into the MCP ecosystem can seamlessly switch to this lower-cost alternative without rewriting workflow logic.

Deep Infra: The Best Value Entry Point for Cloud Models

The author's recommended and primary testing option is Deep Infra. The logic is simple: models run on Deep Infra's servers, not on your local GPU's VRAM, and you only pay for what you use. Setup is straightforward — copy your API key from the Deep Infra dashboard, paste it into Kubrick Studio, save, and test the connection. You'll then have access to around 100 available models.

A few noteworthy details: the key won't be displayed in plaintext after you paste it, so security is maintained; the "Check spend" feature lets you monitor monthly usage and remaining balance to avoid surprise bills. More importantly, on cost — the author is candid that Higgsfield does have more models, but larger models like CDANCE 2.0 and 1.3.0 are available through Deep Infra at lower prices. Cloud models like VOC dance and nano banana appear directly in the model library with individual pricing, no download required.

Ollama: A Completely Free Local Option

For those who want zero cost and maximum privacy, Ollama is the other path. It runs language models on your own GPU — free, private, and your data never leaves your machine. Installation is just a download from Ollama.com; the author jokes that "this section of the tutorial is basically just that."

In the Ollama settings you can change where models are stored (handy if your C drive is tight on space), and context length doesn't need manual adjustment — Kubrick Studio automatically sets it for the agent each time. Once connected, select "Ollama local" in the app and test — no key required, it auto-detects all downloaded models.

About models labeled "obliterated" in their names — these are uncensored versions with the refusal mechanisms removed. Hosted models may decline certain requests; these won't. But the author gives an honest caveat: uncensored doesn't mean better. In his testing, these models were more likely to miss parts of a prompt's requirements. Only reach for them when you genuinely need content they'd otherwise refuse to generate.

Ollama is a local LLM runtime framework that supports running mainstream open-source models like Llama, Mistral, and Gemma on consumer-grade GPUs, abstracting away the complexity of model loading and quantization configuration — users only need a single command to pull and run a model. Its core advantage is that data never leaves the machine, fundamentally eliminating data leakage risk for sensitive or enterprise-private use cases. VRAM is the key constraint: 7B parameter models typically require around 8GB of VRAM, 13B needs about 12GB, and 27B+ requires 24GB or more. "Obliterated" model variants are community-created versions that reverse the alignment fine-tuning process to remove refusal behavior introduced during the RLHF stage — but this can also compromise instruction-following ability, as the author's testing revealed.

Agent Model Selection and Benchmarking

Kubrick Studio includes real benchmark scores for agent models. Top-ranked models are listed with their scores and costs. For example, DeepSeek^Ad v4 flash missed only one item in the test suite, while QN is significantly more permissive with uncensored requests.

Tool-calling ability is verified via "TestToolUse" — confirming the model can actually call the app's tools — while the "benchmark" feature runs a full test suite on any selected model using fake tools (no real content is generated). Checking the share option only uploads results anonymously; prompts and keys are never transmitted. All community results are aggregated at bench.kubrick.studio. The author calls on the community to run and share benchmarks — a model needs three runs before the app adopts its score.

On hardware, the author is upfront that all his local testing was done on a 16GB GPU — "which is not the biggest card." Users with 24GB or more can try Gemma 4 26B and help with benchmarking. He also emphasizes that the score isn't a pass/fail threshold — it tells you "how much human intervention is needed" — and that the benchmark only covers the agent layer, not prompt rewriting or image description.

Tool Use / Function Calling is the core metric for evaluating whether an LLM can serve as an agent's "brain." The model must not only understand natural language instructions, but also correctly parse a tool's JSON Schema definition, output structured call parameters, and track call results across multiple turns. This capability varies significantly across models — at equivalent parameter sizes, models fine-tuned specifically for instruction following and tool calling (such as the DeepSeek series) tend to outperform general-purpose chat models. Kubrick Studio's "fake tools" benchmarking approach draws on offline evaluation methods from academic research: using a simulated environment to validate a model's decision-making logic, avoiding the cost and uncertainty of real calls, while using community crowdsourcing to expand sample coverage and make scores statistically more reliable.

Real-World Usage: Transparent, Controllable Pricing

The demo section is quite telling. The author drags in an image and asks the agent to generate a dragon. After the agent reads the model, the model guide displays the price before running — five cents — and then generates the clip. Switching to Minimax H3, since it isn't installed, the app asks before initiating a 21GB download; he declines, and the app instead offers the H3 reference model he already has — similar results but not identical, and free to run on his local GPU. The agent's own call cost comes to less than one cent.

GPU too small to run local models? The author also offers a RunPod alternative: pay by the GPU-hour rather than per generation, suitable for scenarios where you need heavy compute temporarily. The microphone dictation feature also relies on Deep Infra — enable English dictation and you can speak in any language, with automatic conversion to English input.

How to Connect Your Own Agent

Back to the core use case: your own AI agent can drive Kubrick Studio at Deep Infra prices, or for free on your local GPU. Just click connect under "connect an agent" in settings. Any MCP-compatible agent can connect by adding the corresponding address — Claude Code, Codex, Anti-Gravity, and others can be configured from their GitHub addresses; after confirming, just restart. Claude Desktop requires manually downloading an extension and dragging it into settings. Once connected, the agent can generate images and videos in your projects — paid models will ask first, and the agent cannot delete your projects or charge your payment card.

Overall Assessment

Kubrick Studio represents a pragmatic open-source philosophy: rather than trying to out-model Higgsfield on sheer quantity, it aggregates Deep Infra's low-cost cloud models and Ollama's free local models to minimize the cost of "running AI agents," building trust through transparent pricing prompts and community benchmarking. For users who are budget-conscious, privacy-focused, or looking to build their own agent workflows, it's a worthwhile alternative to explore. Keep in mind that local uncensored models involve quality trade-offs, large model cloud calls still incur per-use charges, and users should make their choice based on their hardware and specific needs.