Engineers Slash $320 AI Bills with Self-Hosted Ollama, OpenHands Stack

Fireship

Developers can eliminate costly proprietary subscriptions by deploying open-source models on private servers, using context compression and tiered proxies to reduce token expenses without losing frontier performance.

AI-assisted summary of 5 open source tools that replaced my $320/mo AI stack... — original source. Check the original for full context.

Source published: 2026-09-07

Key ideas

Maintaining a commercial developer AI stack—combining Cursor ($20), Claude Max ($100), GPT Pro ($100), and Gemini Ultra ($100)—costs at least $320 per month before accounting for supplementary APIs. (0:00)
Developers can cut inference costs and avoid vendor lock-in by pairing Ollama for zero-cost local model execution with 9router, an OpenAI-compatible proxy that automatically cascades queries across paid, pay-per-token, and free fallback tiers. (0:50)
Headroom acts as an inline context compression layer that strips bloated tool outputs and oversized code payloads before they become billable input tokens, while caching original data locally for reversible retrieval. (2:30)
Dify and OpenHands extend the self-hosted stack into production orchestration and autonomous coding, packaging visual LLM pipelines into REST APIs and deploying SWE-bench Verified agents to resolve GitHub issues automatically. (3:41)

Detailed notes

## Background Published on YouTube by Fireship on September 7, 2026, this episode of The Code Report explores five free, open-source tools designed to help developers escape expensive commercial AI subscriptions and dramatically cut token costs. According to the video description, the guide covers Ollama, 9router, Headroom, Dify, and OpenHands as practical self-hosted replacements for proprietary developer stacks.

## TL;DR After tallying an unsustainable $320 monthly bill across services like Cursor, Claude Max, GPT Pro, and Gemini Ultra, Fireship details replacing commercial subscriptions with a self-hosted, open-source developer architecture. The setup leverages Ollama for private local model execution paired with 9router to direct queries through automated fallback tiers and manage downstream APIs. To curb rampant token inflation from developer agents, Headroom applies reversible context compression to logs and code payloads hosted on private VPS infrastructure. The workflow is completed by Dify for visual LLM pipeline orchestration and OpenHands for deploying autonomous, benchmark-tested software engineering agents to resolve GitHub issues.

## Atmosphere & style The video moves at a breakneck pace driven by Fireship's signature deadpan delivery, blending cynical tech satire with genuinely practical systems architecture. It frames the modern software landscape with biting humor, equating corporate AI subscriptions to crippling addictions and ridiculing agents that boil an Olympic swimming pool of compute just to center a div. The viewing experience feels like a high-energy, meme-fueled tech dispatch that balances absurd real-world parodies, such as a horse dating app, with empowering open-source engineering.

## Bulletin - [00:00](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=0s) Maintaining a commercial developer AI stack—combining Cursor ($20), Claude Max ($100), GPT Pro ($100), and Gemini Ultra ($100)—costs at least $320 per month before accounting for supplementary APIs. - [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) Developers can cut inference costs and avoid vendor lock-in by pairing Ollama for zero-cost local model execution with 9router, an OpenAI-compatible proxy that automatically cascades queries across paid, pay-per-token, and free fallback tiers. - [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) Headroom acts as an inline context compression layer that strips bloated tool outputs and oversized code payloads before they become billable input tokens, while caching original data locally for reversible retrieval. - [03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) Dify and OpenHands extend the self-hosted stack into production orchestration and autonomous coding, packaging visual LLM pipelines into REST APIs and deploying SWE-bench Verified agents to resolve GitHub issues automatically.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=0s) A standard commercial AI subscription stack—comprising Cursor ($20/mo), Claude Max ($100/mo), GPT Pro ($100/mo), and Gemini Ultra ($100/mo)—reaches $320 per month before counting additional services like ElevenLabs, DeepSeek, or forgotten API keys. - [00:00](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=0s) Replacing commercial SaaS subscriptions with a self-hosted open-source AI stack lowers costs and gives developers full control while retaining the flexibility to fall back on frontier models from OpenAI and Anthropic when raw compute is needed. - [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) Ollama functions like "Docker for large language models," providing a command-line interface and standard API to pull and run models on local hardware with complete source-code privacy and zero inference costs. - [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) While local execution via Ollama works well for small models on consumer hardware, running frontier-class reasoning models locally remains impractical due to massive compute requirements. - [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) 9router exposes a unified, OpenAI-compatible proxy on localhost that eliminates manual API key rotation across vendors while logging usage and compressing tool output. - [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) Using 9router's prioritized fallback tiers, queries can start on flat-rate plans like Claude Max (Tier 1), automatically downgrade to pay-per-token OpenAI backups when quotas are exhausted (Tier 2), and fail over to free cloud credits, open-weight models, or local Ollama instances (Tier 3). - [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) Developer coding agents frequently waste massive amounts of billable input tokens by ingesting oversized files—such as a 50,000-line package.json—to solve trivial tasks. - [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) Headroom sits between client applications and upstream inference providers to intercept and strip non-essential data from raw tool outputs, system logs, and code payloads before billing occurs. - [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) Headroom's compression is fully reversible because it caches the original uncompressed content locally, allowing the language model to selectively retrieve full-fidelity data slices during intermediate reasoning. - [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) This entire suite of Docker-based AI services—including Ollama, 9router, Headroom, and agent frameworks—can be self-hosted on a single Virtual Private Server (VPS) using one-click Docker catalog templates. - [03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) Dify provides an open-source visual workflow builder that lets developers connect database retrieval and LLM evaluation nodes on a canvas and expose the entire logic chain as a production-ready REST API. - [03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) OpenHands is a top-ranking autonomous software engineering agent on the SWE-bench Verified benchmark that runs a self-hosted background workforce to resolve GitHub issues using either commercial frontier models or zero-cost local Ollama models.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=0s) Escaping the $320/Month "Big AI" Addiction

Doing a quick financial audit reveals a startling reality about the modern software development landscape: keeping up with cutting-edge artificial intelligence tools has become outrageously expensive. Tallying up the monthly toll shows $20 for Cursor, $100 for Claude Max, another $100 for GPT Pro, and an additional $100 for Gemini Ultra—not counting subscriptions to ElevenLabs, DeepSeek, or a graveyard of forgotten API keys set up two years ago. The financial strain of maintaining this AI habit reached a point where drastic lifestyle sacrifices had to be made, forcing an end to vices like alcohol and ZYN. With US alcohol sales sinking to historic lows, "Big AI is the one to blame for this."

This financial wake-up call prompted a complete cancellation of these commercial subscriptions in favor of self-hosting a developer AI stack on private infrastructure. Broadcasting on September 7th, 2026, on *The Code Report*, this new setup proves to be substantially cheaper, vastly more productive, and completely under developer control, while still maintaining the flexibility to fall back onto frontier models from Anthropic and OpenAI when raw compute is essential.

- **Monthly Cost Breakdown:** - Cursor: $20/month - Claude Max: $100/month - GPT Pro: $100/month - Gemini Ultra: $100/month - Total base stack: $320/month (excluding ElevenLabs, DeepSeek, and forgotten legacy APIs)

---

[00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) Ollama and 9router: Local Execution and Intelligent Fallback

Every functional AI architecture requires an underlying model engine. For the average developer, that means shipping proprietary source code directly to trillion-dollar tech conglomerates while hoping they keep it secure. The alternative is Ollama, an open-source tool functioning essentially as "Docker for large language models." It provides a clean command-line interface and standard API for pulling and executing models directly on local hardware. Ollama keeps prompts entirely confidential and reduces inference costs to exactly zero dollars, meaning "the model continues to work even after your credit card is declined." However, the major tradeoff is raw computing power: small models run on standard consumer hardware, but frontier-class reasoning models demand a small data center—a severe roadblock for any "vibe engineer who needs to write top-tier slop."

To solve the hardware ceiling without reintroducing subscription chaos, the stack incorporates 9router. Sitting between local developer tooling and dozens of downstream model vendors, 9router exposes a unified, OpenAI-compatible proxy running on `localhost`. Instead of manually rotating nine distinct vendor keys, all traffic flows into a single endpoint powered by intelligent fallback tiers. If high-priority slots exhaust their quotas, queries automatically downgrade to secondary or free tiers without developer intervention, while simultaneously logging usage and compressing tool output to minimize token consumption.

```mermaid flowchart TD accTitle: 9router Request and Fallback Flow accDescr: Architecture of 9router directing queries through prioritized fallback tiers. subgraph ClientLayer ["Client Interface"] APP["Local Tools & Dev Apps"] end

subgraph RouterLayer ["Local Proxy"] ROUTER["9router (Localhost Endpoint)"] end

subgraph TierLayer ["Configured Fallback Tiers"] T1["Tier 1: Claude Max (Paid Plan)"] T2["Tier 2: Pay-Per-Token OpenAI Backup"] T3["Tier 3: Free Providers & Local Ollama"] end

APP --> ROUTER ROUTER -->|"Primary Query"| T1 T1 -.->|"Quota Exceeded"| T2 T2 -.->|"Failover"| T3 ```

- **9router Fallback Tier Hierarchy:** - **Tier 1:** Pre-existing flat-rate subscriptions (e.g., Claude Max) - **Tier 2:** Pay-as-you-go, low-cost token APIs (e.g., cheaper OpenAI models) - **Tier 3:** Zero-cost fallback providers (open-weight Chinese models, Google Cloud Vertex AI trial credits, or local Ollama instances)

---

[02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) Headroom: Context Compression and Hosting Infrastructure

Even with disciplined routing, developer agents remain notorious token gluttons. A simple request like asking an agent to center a `div` often leads it to ingest a 50,000-line `package.json` file, effectively evaporating "an Olympic-size swimming pool worth of water just to realize it needs to install Tailwind CSS." To prevent massive input token billing, Headroom acts as an inline context compression layer positioned between the client application and upstream inference providers.

Headroom intercepts raw tool outputs, system logs, and oversized code payloads, stripping out non-essential data before it transforms into billable input tokens. Crucially, this compression mechanism is fully reversible: all original uncompressed content sent downstream is cached on the local machine. Should the language model discover during intermediate reasoning that it requires full fidelity on an omitted slice of logs or code, it can selectively retrieve the full data from cache.

Hosting this array of Docker-based services requires dedicated server infrastructure. Hostinger serves as the backbone virtual private server provider, featuring an integrated Docker catalog in its control panel that enables one-click deployment for tools like 9router, Headroom, Ollama, and agent frameworks on a single unified instance.

---

[03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) Dify and OpenHands: Visual Workflows and Autonomous Coding Agents

With infrastructure and routing configured, application logic moves beyond raw prompt engineering into structured orchestration via Dify. Dify is an open-source visual workflow builder allowing developers to configure LLM pipelines by arranging and connecting functional nodes on a canvas. The video illustrates this through the satirical dating app "Horse Tinder" and its automated matchmaking engine.

```mermaid flowchart LR accTitle: Horse Tinder AI Matchmaking Pipeline in Dify accDescr: End-to-end flow of Dify orchestrating horse profile matches and exposing an API. subgraph Intake ["App Action"] USER["User Swipes Right"] PROFILE["Profile Payload"] end

subgraph DifyCanvas ["Dify Visual Workflow Engine"] DB["DB Candidate Retrieval"] LLM["LLM Match Evaluation"] end

subgraph Delivery ["External Output"] API["Exposed REST API"] RESULT["Client UI Display"] end

USER --> PROFILE PROFILE --> DB DB --> LLM LLM --> API API --> RESULT ```

In this pipeline, horse profiles are passed into Dify, matching candidates are pulled from a relational database, and an LLM evaluates behavioral compatibility—generating explanations such as determining that "Thunder and Butternuts are a 94% match because they both enjoy trail rides and biting children." Dify packages the entire visual logic chain into a production-ready REST API that the front-end application queries instantly upon a right swipe.

Building applications manually, however, was fundamentally disrupted in Q2 2026 with the emergence of OpenHands, an open-source software engineering agent that enables engineers to "fire yourself." OpenHands ranks as a top performer on the SWE-bench Verified benchmark, which evaluates an AI's ability to autonomously resolve real-world GitHub issues. Rather than writing code by hand, developers manage a self-hosted command center running a persistent background workforce of agents triggered by repository issues. Because OpenHands runs self-hosted on a private VPS, it can be driven either by proprietary frontier models from Anthropic and OpenAI or by completely private, zero-marginal-cost models hosted locally through Ollama.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=0s) Big AI is the one to blame for this.

> [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) Docker for large language models.

> [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) the model continues to work even after your credit card is declined.

> [00:50](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=50s) vibe engineer who needs to write top-tier slop.

> [02:30](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=150s) an Olympic-size swimming pool worth of water just to realize it needs to install Tailwind CSS.

> [03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) Thunder and Butternuts are a 94% match because they both enjoy trail rides and biting children.

> [03:41](https://www.youtube.com/watch?v=Y5rSSvXfL4g&t=221s) fire yourself.

## Mentioned Cursor, Claude Max, GPT Pro, Gemini Ultra, ElevenLabs, DeepSeek, Anthropic, OpenAI, The Code Report, Ollama, Docker, 9router, Google Cloud Vertex AI, Headroom, Tailwind CSS, Hostinger, Dify, OpenHands, SWE-bench Verified, GitHub

## Video description Get 67% off VPS hosting with Hostinger's one-click templates. Use code FIRESHIP for an extra discount - https://hostinger.com/fireship

In this video we cover 5 free and open-source tools that'll help you cut token costs. Let's dive in.

- Ollama - 9router - Headroom - Diffy - OpenHands

#coding #programming

Want more Fireship?

🗞️ Newsletter: https://bytes.dev 🧠 Courses: https://fireship.dev

[Source](https://www.youtube.com/watch?v=Y5rSSvXfL4g)

中文简报

工程师借助自托管 Ollama 与 OpenHands 技术栈大幅削减 320 美元 AI 账单开发者可通过在私有服务器上部署开源模型，并利用上下文压缩和分层代理减少 Token 开销，在不牺牲前沿性能的前提下免去昂贵的专有订阅费用。在累计了 Cursor、Claude Max、GPT Pro 和 Gemini Ultra 等服务每月高达 320 美元且不可持续的账单后，Fireship 详细介绍了如何用自托管的开源开发者架构替代商业订阅。该方案利用 Ollama 在本地私有环境中运行模型，并配合 9router 通过自动化后备层级引导查询以及管理下游 API。为遏制开发者 Agent 带来的 Token 暴增，Headroom 对托管在私有 VPS 基础设施上的日志和代码负载应用可逆上下文压缩。整个工作流还包括使用 Dify 进行可视化 LLM 管道编排，以及使用 OpenHands 部署经过基准测试的自主软件工程 Agent 来自动解决 GitHub Issue。维持一套商业开发者 AI 技术栈——包括 Cursor（20 美元）、Claude Max（100 美元）、GPT Pro（100 美元）和 Gemini Ultra（100 美元）——在未计入额外 API 的情况下，每月至少花费 320 美元。 (0:00) 开发者可以通过将零成本运行本地模型的 Ollama 与 9router 配合使用，来削减推理成本并避免供应商锁定；9router 是一个兼容 OpenAI 的代理，可在付费、按 Token 付费和免费后备层级之间自动级联分发查询。 (0:50) Headroom 可作为内联上下文压缩层，在臃肿的工具输出和过大的代码负载变成计费输入 Token 之前将其剥离，同时在本地缓存原始数据以实现可逆检索。 (2:30) Dify 和 OpenHands 将这一自托管技术栈扩展到了生产编排和自主编码领域，把可视化 LLM 管道封装为 REST API，并部署通过 SWE-bench Verified 验证的 Agent 来自动解决 GitHub Issue。 (3:41)

Reading summary

Fireship argues that developers can replace expensive commercial AI subscriptions costing over $300 per month by self-hosting an integrated stack of open-source model runners, proxies, compressors, and autonomous agents on private infrastructure. The Unsustainable Cost of Commercial AI (0:00) Maintaining cutting-edge artificial intelligence tooling has become increasingly costly for developers. A typical base stack can reach $320 each month by combining Cursor at $20, Claude Max at $100, GPT Pro at $100, and Gemini Ultra at $100, before accounting for legacy APIs or supplementary tools like ElevenLabs and DeepSeek. Local Execution and Tiered Proxy Routing (0:50) To eliminate ongoing inference fees and preserve code privacy, developers can run open-weight models locally with Ollama. Operating like Docker for language models, Ollama offers a CLI and API that execute models at zero marginal cost, though running top-tier reasoning models remains constrained by consumer hardware limits. Context Compression and Unified VPS Infrastructure (2:30) To handle large upstream token bills caused by developer agents reading oversized files, Headroom functions as an inline context compression layer. It strips non-essential data from tool outputs and code payloads while caching the original content locally so models can retrieve full-fidelity data if required during reasoning. Visual Workflows and Autonomous Engineering Agents (3:41) At the application layer, Dify enables visual workflow creation by connecting functional nodes—such as database retrieval and model evaluation—and deploying them directly as REST APIs. For coding tasks, OpenHands operates as a self-hosted software engineering agent that scored as a top performer on the SWE-bench Verified benchmark for solving GitHub issues. Self-hosting these open-source tools allows developers to run private, lower-cost workflows, though high-end autonomous coding and complex reasoning still depend on fallback access to frontier models when local compute hits hardware constraints.

Source quotes

[0:00] Big AI is the one to blame for this. [0:50] Docker for large language models. [0:50] the model continues to work even after your credit card is declined. [0:50] vibe engineer who needs to write top-tier slop. [2:30] an Olympic-size swimming pool worth of water just to realize it needs to install Tailwind CSS. [3:41] Thunder and Butternuts are a 94% match because they both enjoy trail rides and biting children. [3:41] fire yourself.

Original transcript

[0:00] But recently, I did some math and it [0:02] made me realize how broken the world is. [0:04] A cursor, $20. Claude Max, $100. GPT [0:07] Pro, another 100. Gemini Ultra, another [0:10] 100. Not to mention 11 Labs, Deep Seek, [0:12] and all the API keys I signed up for 2 [0:15] years ago and forgot about. My AI [0:16] addiction got so expensive that I had to [0:18] quit alcohol and Zen. And I'm not the [0:20] only one because alcohol sales in the [0:22] United States are currently sitting at [0:23] historic lows. And Big AI is the one to [0:26] blame for this. But that was my wake-up [0:27] call. And since then, I've canceled all [0:29] these subscriptions and now self-host [0:31] the ultimate AI stack for developers [0:33] that's not only cheaper, but far more [0:35] productive. In today's video, we'll look [0:37] at a bunch of free and open-source [0:39] projects you can run on your own server. [0:41] We'll make them work together while [0:42] still having the option to tap into the [0:44] intelligence of big models like Claude [0:46] and GPT sold. It is September 7th, 2026 [0:49] and you're watching The Code Report. The [0:50] first tool we need to talk about is [0:52] Ollama because every AI stack first [0:54] needs a model. For most people, this [0:56] means sending your proprietary code to a [0:58] trillion-dollar corporation and trusting [1:00] them to keep it totally safe. Or you can [1:02] use Ollama and do everything locally. [1:04] I've talked about this tool many other [1:05] times on the channel, and essentially, [1:07] it's like Docker for large language [1:09] models. It gives you a simple [1:10] command-line interface and API for [1:12] downloading and running models on your [1:14] own machine. This is great if you want [1:15] to try out the latest Chinese models or [1:17] any other open-weight models. And what's [1:19] even better is that all your prompts [1:21] stay private and the inference cost is [1:23] zero, which means the model continues to [1:25] work even after your credit card is [1:26] declined. The big problem though is that [1:28] you probably don't own the hardware to [1:30] run anything close to state-of-the-art. [1:32] The small models will run almost [1:33] anywhere, but running a frontier-sized [1:35] model will require a small data center. [1:37] And that's a big problem if you're a [1:38] vibe engineer who needs to write [1:39] top-tier slop. Luckily, there's a [1:41] self-hostable solution to this called [1:43] Nine Router, which is an AI tool that [1:45] sits between your AI tools and dozens of [1:47] different model providers through one [1:49] local endpoint. Instead of juggling nine [1:51] different API keys, Nine Router provides [1:53] one door with an OpenAI compatible proxy [1:56] that allows you to point everything [1:57] through localhost, but the thing that's [1:59] really cool about Nine Router is [2:01] fallback tiers. On tier one, you might [2:03] have an existing subscription like [2:05] Claude Max that you already pay for. [2:07] Then on tier two, you might have a cheap [2:09] paper token OpenAI model as a backup. [2:11] Then tier three has all of your free [2:13] providers like Chinese models, Vertex [2:15] trial credits, and so on. That means if [2:17] you max out Claude Max, it'll [2:19] automatically roll over to the next tier [2:20] without you having to do anything. But [2:22] in addition to that, Nine Router also [2:24] tracks usage and will compress your tool [2:26] output to reduce token consumption, [2:28] which will ultimately save you a bunch [2:29] of money. But if you're still eating [2:31] billions of tokens per day, then you [2:33] need to know about Headroom, which is a [2:35] context compression layer for AI agents. [2:37] You ask AI to center a div, and to do [2:39] that, it reads 50,000 lines of your [2:41] package.json file. Then it evaporates an [2:43] Olympic-size swimming pool worth of [2:45] water just to realize it needs to [2:47] install Tailwind CSS. Headroom sits [2:49] between your application and the model [2:51] provider and compresses everything from [2:53] tool outputs to log files and any other [2:55] useless chunks before it actually goes [2:57] to the model, which would be billable [2:59] input tokens. And one clever design [3:01] feature of this tool is that it's [3:02] reversible. The compressed content that [3:04] ships to the model is cached on your [3:06] local machine, which means if the model [3:08] ever needs it, it can always retrieve [3:09] it. This sounds awesome, but at this [3:11] point, you might be wondering, where do [3:13] I deploy all this stuff? Well, the [3:14] answer, of course, is Hostinger, the [3:16] sponsor of today's video. Not only is it [3:18] one of the most affordable places to [3:19] host your own virtual private server, [3:21] but they also have an entire Docker [3:23] catalog built into the panel, which [3:25] means every single open source project I [3:27] talk about in this video can be hosted [3:29] there with a single click. In fact, you [3:31] could have all these tools running and [3:32] working together on the same VPS. Head [3:34] over to hostinger.com/fireship [3:37] and use my coupon code to save a bunch [3:38] of money spinning up your own VPS. Once [3:41] you have that done, the next tool you'll [3:42] want to install there is Diffy. [3:44] Everything we've talked about so far is [3:45] infrastructure, but now it's time to [3:47] build an actual app that'll make us [3:49] rich. Instead of trying to engineer [3:50] everything through prompts, Diffy is a [3:52] visual builder that allows us to drag [3:54] nodes on a canvas. This has been a [3:56] game-changer for Horse Tinder and its AI [3:58] matchmaking feature. The app will send [4:00] Dify each horse's profile information, [4:03] then a visual workflow retrieves [4:04] compatible horses from the database and [4:06] uses a large language model to explain [4:08] each match. Like Thunder and Butternuts [4:10] are a 94% match because they both enjoy [4:13] trail rides and biting children. Then [4:15] the entire workflow is exposed as an [4:16] API, so the front-end application can [4:18] just call it whenever a horse swipes [4:20] right. Amazing, but building apps as a [4:22] human became outdated in Q2 2026 after [4:26] the release of Open Hands, which is an [4:28] open-source tool that allows you to fire [4:30] yourself. This tool is a top-performing [4:32] autonomous coding agent on SWE-bench [4:34] verified, which is the benchmark where [4:36] models fix real GitHub issues. Instead [4:38] of trying to build and fix things, just [4:40] open up GitHub issues and let Open Hands [4:42] do all the work. Essentially, it gives [4:44] you a command center where you can [4:45] self-host an army of AI agents that are [4:48] always on and working in the background. [4:49] And because it's running on your own [4:51] virtual private server, you have the [4:52] option to run it with OpenAI or [4:54] Anthropic models or use the local LLMs [4:57] that you installed earlier with Ollama. [4:58] And now at this point, we have our own [5:00] private AI stack that could build any [5:02] type of software you can imagine. But [5:04] this is just the tip of the iceberg and [5:05] there's tons of other open-source [5:07] applications in Hostinger's Docker [5:08] catalog that you can install with zero [5:11] hassle. Check out the link below and use [5:13] coupon code fireship to get your own [5:15] virtual private server on Hostinger up [5:17] and running right now. This has been the [5:18] Code Report. Thanks for watching and I [5:20] will see you in the next one.