AI is changing the world. Don't stay behind. Clear summaries, community insight, delivered without the noise. Subscribe to never miss a beat.

Building an (almost) fully self-hosted, sandboxed, agentic software factory

blog.jakesaunders.dev

August 21, 2026

11 min read

🔥🔥🔥🔥🔥

47/100

Summary

Jake Saunders built a mostly self-hosted agentic development environment that turned a single prompt into a deployed calorie-tracking application. Hermes, an OpenClaw-style assistant using OpenAI Codex for inference, created a Forgejo repository, generated a SvelteKit application with Drizzle, Postgres and Tailwind, wrote tests, configured CI, fixed failed tests, containerized the software, and deployed it through Coolify. After a later report of a CSRF bug, Hermes diagnosed the issue, added regression tests and redeployed the application. The environment runs on a separate 2021 10th-generation i7 machine with 32GB of RAM rather than the homelab server hosting other services. Coolify provides self-hosted Docker-based deployment, Forgejo supplies Git and CI runners, and Firecrawl provides web scraping and search access. Tailscale and Pi-hole make internal services reachable remotely, while DNS-01 validation through Porkbun and Let’s Encrypt issues HTTPS certificates without public A or AAAA records for the services. The setup still depends on external inference and integrations, including Codex, Tailscale, Telegram, Porkbun and Let’s Encrypt; the stated experiment-specific ongoing cost is a £20 Codex subscription. Saunders says the isolation limits the impact of agent mistakes but does not make the system safe: Hermes can still erase the dedicated machine, delete local resources, misuse supplied credentials, make outbound requests, and reach network resources permitted by firewall rules.

Key Takeaways

Hermes autonomously built, tested, committed, and deployed a SvelteKit calorie-tracking app from one prompt using Forgejo, Coolify, Docker Compose and Postgres.
The deployment environment runs on a dedicated 2021 10th-generation i7 system with 32GB RAM, separating the agent from a separate homelab server hosting roughly 45 containers.
Tailscale, Pi-hole and DNS-01 certificate validation let internal Coolify services use valid Let’s Encrypt HTTPS certificates without public A or AAAA records pointing at them.
The system is not fully self-hosted: Codex supplies inference, and Tailscale, Telegram, Porkbun and Let’s Encrypt remain external services.
A dedicated machine reduces the blast radius of agent failures, but the agent can still destroy local data, abuse granted credentials, make outbound requests, and access firewall-permitted network resources.

What the discussion said

The thread treated the self-hosted agentic factory less as a clever orchestration diagram than as a test of whether AI-generated software can be trusted. The strongest consensus was that producing code is no longer the hard part; verifying it is. Readers described agents generating unit, integration, and end-to-end tests that still imposed a heavy human review burden, because an agent can easily encode the same mistaken assumptions in both implementation and tests. A production-faithful, hermetic environment emerged as the most credible answer, alongside ideas for testing against deliberately buggy simulations rather than merely checking that generated tests pass. People were also keenly interested in the practical boundary between local and cloud models. Some reported that recent Qwen variants on consumer hardware are useful enough to replace cheaper cloud-model work, with strong coding output at high token rates on expensive GPUs. Others found self-hosted coding models disappointing and still see frontier-provider models as necessary for difficult work. Everyday agent deployments, from home automation configuration to analyzing sensor history, gave the concept real appeal, but skeptics stressed that feature-breaking bugs remain beyond even top models and that chasing exact requirements makes the final stretch slow and token-hungry. The prevailing mood is hopeful experimentation, not confidence that autonomous software delivery has arrived.

Where opinion split

The central dispute is whether a self-hosted, agent-run software factory is already practical or still a seductive demo. Optimists argue that capable local models, sandboxing, and increasingly mature orchestration can automate substantial routine work today, and that the capability curve is still climbing fast. Skeptics counter that unsolved bugs, weak independent verification, and expensive human oversight mean the system cannot yet be trusted to deliver production software autonomously.

Read original article

Community Sentiment

Mixed

Positives

Recent local Qwen coding models are reportedly strong enough to absorb a meaningful share of routine cloud-model work, making private AI assistance more attainable for hardware owners.
Agentic tools have already proved useful for bounded real-world tasks such as configuring home automation and mining historical sensor data for operational conclusions.
Hermetic environments that mirror production give AI-generated changes a credible proving ground, turning verification from an afterthought into usable infrastructure.
Several readers see autonomous development as an immature but rapidly improving capability, worth building around now rather than dismissing because it is imperfect.

Concerns

Generated tests do not establish correctness when the same model can repeat its flawed premise in the code and the test suite, leaving humans as the real verification loop.
Reviewing agent-written unit, integration, and end-to-end tests can become its own exhausting bottleneck, erasing much of the promised automation.
Local coding-model results remain uneven, and some readers still find frontier cloud models necessary for difficult engineering tasks despite the self-hosting appeal.
Even leading models can stall for hours on feature-breaking frontend and embedded defects, while exacting requirements turn the final increment of work into a costly token sink.