Factory: The Next Phase of Hybrid AI Development A developer built Factory, a web UI that sits between a GitHub issue backlog and a Claude Code-based coding harness, scoring and prioritizing issues with a local model before handing selected work to frontier cloud models. The setup runs the dev harness and background agents on a dedicated Intel NUC with 32GB of RAM, separating heavy agent loops from the primary laptop, and chains local models for classification, evaluation and triage with cloud models for code generation. Originally published at jduncan.io https://jduncan.io/blog/2026-09-08-factory-the-next-phase-of-hybrid/ . A couple weeks ago I wrote about my hybrid LLM setup https://jduncan.io/blog/2026-08-27-hybrid-llms-cloud-for-code-local-for-home . At the time, the division seemed simple enough: cloud models for writing code, and a local server in my house for family life, privacy, and experiments. That split was always a temporary checkpoint. I spend a lot of my spare time building BrandCast https://brandcast.app . It's a large monorepo with thousands of moving parts. Over the past year, I've poured a huge amount of effort into dialing in its AI harness. I use Claude Code as my primary pair programmer, backed by custom skills, system prompts, and my Root development framework https://jduncan.io/blog/2026-03-22-introducing-root-structured-ai-development . At this point, the harness is predictable. If my input context is clean, I can predict the quality of the output with high confidence. The problem isn't the code generation anymore. The problem is the friction around it. Sitting in front of a terminal hitting enter every few minutes gets old fast. I don't want an interactive copilot glued to my face all evening. I want an autonomous software factory. Most conversations about AI agents suffer from binary thinking. One camp insists on running everything locally. They imagine an 8B or 32B model refactoring hundreds of files across a massive monorepo with zero external API calls. I love my local hardware, but that's fantasy today. When the cost of a wrong edit is high, you pay for the frontier model. Local models don't have the context coherence or reasoning depth to navigate deep monorepo migrations without going off the rails. The other camp hands their credit card over to cloud agents for every tiny step. They spin up autonomous swarms that burn millions of frontier tokens just reading GitHub issues, hallucinating roadmaps, and doing basic ticket triage. The reality is more nuanced. Frontier models are expensive and rate-limited. You don't use a master craftsman to sweep the workshop floor or sort tickets into neat piles. You use them to build the intricate mechanisms. Local models, on the other hand, are fast, private, and practically free once the server is paid for. They aren't ready to rewrite my backend, but they are fantastic at classification, evaluation, and triage. The logical step isn't choosing between local and cloud. It's chaining them together. Before I could automate the factory floor, I had to fix where it lived. For months, I ran my entire development harness directly on my MacBook. If you've ever run continuous agent loops, multiple git worktrees, Docker test containers, and local build tools on your primary laptop, you know the pain. The fans spin up. The battery melts. Your terminal history turns into an unreadable blur of agent output. Worst of all, your working git tree is constantly in flux. So I moved the bulk of my BrandCast development off my laptop entirely. I set up a dedicated Intel NUC with 32GB of RAM. It sits quietly on my network, always powered on, running the dev harness and the background agents. That hardware separation changed how I think about my time: With the harness running on the NUC, I built a small web UI to manage the flow. I call it Factory. It sits between my GitHub issue backlog and my coding harness. Here's what is happening behind that screen: Instead of staring at a sprawling backlog and wondering what to tackle next, I have a prioritized queue scored by a model that didn't cost me a penny in API tokens. Here's how the entire topology fits together across the laptop, the NUC, the local inference box, and the cloud: Notice how each machine has a dedicated responsibility: Factory gives me two execution modes depending on how involved I want to be. Sometimes I want specific control over what runs. I open Factory, look through the top 15 ranked issues, find the one I care about, and click run . Factory immediately launches a backgrounded Claude Code session on the NUC. It provisions an isolated git worktree so the main repository tree isn't touched. The session boots with my full configuration: project-specific MCP servers, custom system prompts, and the Root dev workflow. The agent reads the issue, writes the plan, edits the code, runs the tests, and pushes a PR. I can monitor it if I want, or go back to whatever else I was doing on my laptop. This is where the setup becomes genuinely autonomous. I click run at the top of the queue and let Factory take the wheel. Factory grabs the top-ranked issue and kicks off the background session. While Claude Code works through the Root workflow, Factory continuously polls GitHub Actions to monitor build and test progress. When the pull request passes CI and merges into main , Factory runs its teardown routine: cleaned /home/jduncan/Code/bc-4377 . If you've heard me speak at Google Cloud recently, you've heard this exact talk track. Enterprises are wrestling with the exact same challenge. Everyone knows how to hook up an LLM to an IDE. The real question is how to scale agentic development without burning out your developers, draining your API budget on trivial tasks, or letting unvetted code run wild. The answer is division of labor. Use the frontier model for what it does best: large-scale, complex reasoning and code modifications in a massive codebase. Augment it with a local LLM to automate your supervisory duties away. Offload the heavy execution to a dedicated machine so your primary workstation stays free for creative thought. This is me eating my own dogfood. I have a Claude 20x Max plan. Let's see how well it holds up when a local factory keeps feeding it work around the clock. If you're looking at your own development workflow and wondering how to take the next step toward autonomy, keep these principles in mind: Hybrid AI isn't just about where your data lives. It's about how your models collaborate across your hardware. And right now, the factory floor is humming.