Building With AI Agents as Co-Workers: My Stack, My Costs, and What I Actually Learned

TL;DR: One person, 10 projects, ~3 articles/day, €26/month. Stack: OpenClaw (custom publish server) + n8n (orchestration) + LiteLLM (model routing) + Coolify on Hetzner (self-hosting). The key is treating AI as a co-worker running autonomous processes — not a tool you prompt reactively.

I’ve stopped thinking about AI as a tool I use. I think about it as the team I work with.

That reframe changes everything — what you build, how you build it, and what you’re willing to invest in making it work well. This is a writeup of the stack I’ve assembled over the past year to run 10 projects, multiple SaaS products, and a content pipeline that publishes automatically while I sleep. The goal isn’t to impress anyone with complexity. It’s to show what’s actually possible when one person treats AI agents as co-workers rather than autocomplete.

The Philosophy First

Most people using AI are asking it to write emails faster. That’s fine. But the more interesting question is: what happens when you stop being the bottleneck?

Every organisation has processes that bottleneck on human time: content production, data analysis, customer communication, reporting. AI agents can run these processes autonomously — not perfectly, but reliably enough to matter. The question is how to orchestrate them at a cost that makes sense.

My thesis: a solo operator with well-designed agent infrastructure can run what used to require a team of 5–10 people. The competitive advantage isn’t the AI — it’s the infrastructure around the AI.

The Stack

OpenClaw — Custom Agent Infrastructure

OpenClaw is the publishing and coordination layer between my AI workflows and my websites — a webhook server built by a talented developer that I’ve integrated into my stack.

When an n8n workflow generates an article, it doesn’t push to GitHub directly. It calls OpenClaw with a JSON payload: slug, site identifier, content. OpenClaw handles the file writing, git commit, push to the correct repository, Telegram notification, and triggering the newsletter dispatch.

Why use this instead of something off the shelf? Because the off-shelf options either cost too much, require too much configuration per site, or don’t give the control I want over the publish pipeline. OpenClaw runs as a Python webhook server on my Hetzner VPS, handles 8 sites, and has been running without issues.

The lesson: sometimes the right tool is a focused, well-built component you control completely.

n8n — Workflow Orchestration

n8n is the brain of the operation. It handles:

• Scheduled triggers for content generation
• API calls to LLM providers
• Data transformation between steps
• Webhook routing for approvals and notifications
• Database queries for analytics data

I want to be clear: n8n is not the only way to do this. It’s a visual workflow tool that makes certain things fast to build and easy to inspect. For someone comfortable with code, a Python script or TypeScript serverless function might be cleaner for complex logic.

What n8n is good at: connecting services quickly, running on a schedule, handling webhooks, and being debuggable by non-engineers. What it’s bad at: complex control flow, error handling that requires real programming logic, and anything involving large data volumes.

I’ve hit all its walls. Backtick template literals cause silent failures. Parallel fan-out is unreliable without explicit merge nodes. Credentials don’t inject properly into HTTP request bodies. None of these are dealbreakers — they’re just things you learn.

LiteLLM — Model Routing Layer

LiteLLM is a proxy that sits between my applications and the LLM APIs (OpenAI, Anthropic, Groq, Gemini). Every AI call in my stack goes through LiteLLM.

The benefits:

• Model agnosticism — I can swap from Groq to Anthropic without changing application code
• Cost tracking — per-project spend tracked in a dashboard
• Rate limiting — prevents any single workflow from burning through my API quota
• Fallback routing — if Groq is down, automatically route to a backup provider
• Unified logging — every prompt and completion logged with cost and latency

For a multi-site operation, the cost tracking alone is worth it. I know exactly how much each article costs to generate, which sites are most expensive, and where I can optimise.

Current model split: Groq (LLaMA 3.3 70B) for most content generation (fast, cheap, good enough), Gemini 1.5 Flash for structured data tasks, Claude Sonnet for anything requiring nuanced reasoning.

Coolify — Self-Hosting Layer

Coolify is the platform layer that manages all my containers on a single Hetzner VPS. It handles deployments, SSL certificates, reverse proxying, environment variables, and service health monitoring through a UI I can actually use.

Running on Coolify: n8n, LiteLLM, Umami (analytics), Listmonk (newsletter), Minio (object storage), OpenClaw, and Postgres.

All of this on a Hetzner CX32 — 4 vCPU, 8GB RAM — at €15/month.

The Coolify decision was one of the best infrastructure choices I’ve made. The alternative was a collection of managed services: managed n8n ($50/month), managed analytics ($30/month), managed email ($20/month), managed storage ($10/month). That’s $110/month before LLM API costs, versus €15/month self-hosted on Hetzner.

Self-hosting has a reputation for being fragile and time-consuming. With Coolify, it’s neither. Deployments are one-click. Backups are automated. The operational overhead is maybe 30 minutes a month.

The Agent Workflows

The actual AI agents are n8n workflows, but I think of them as agents because they operate autonomously with goal-directed behaviour:

Content agents run on schedule. Each site has a research agent (reads performance data, current events, generates topic ideas) and a generation agent (writes the article, scores quality, publishes if it passes). They run without intervention.

Analytics agents run daily and weekly. They pull data from Umami, compare against previous periods, identify trends, and send me a Telegram summary. I wake up every morning knowing how every site performed overnight.

Approval agents handle the exception cases. Some sites (my personal blog) require my sign-off before publishing. The agent generates the content, sends me a Telegram message with inline buttons, and waits. I approve or reject with one tap.

Error agents watch everything else and notify me when something breaks.

The result: I have maybe 15 minutes of active work per day related to the content operation. Everything else runs.

What It Actually Costs

Seven sites. Three daily AI workflows per site. Analytics, newsletter, social posting. All of it for under €30/month.

The ceiling on this isn’t money — it’s the quality of the outputs and how much I want to scale.

What I’d Do Differently

Start with the feedback loop. I spent months publishing content before building the analytics pipeline that tells me what’s working. Build observability first.

Don’t over-engineer orchestration. I’ve rebuilt some workflows three times trying to make them “correct.” A workflow that runs reliably and is slightly ugly beats an elegant one that breaks. Embrace the duct tape.

LiteLLM from day one. Routing LLM calls through a proxy from the start would have saved me significant cost and debugging time. Going back to add it later required updating every workflow.

Separate concerns clearly. OpenClaw exists because I tried to do too much inside n8n (file system operations, git commands, complex conditional logic). Pushing those concerns into a dedicated service made everything cleaner.

What AI Agents Are and Aren’t

They’re not magic. The content they produce is good but not great — it lacks the depth and originality of work produced by someone who has spent years thinking about a topic. The analytics they generate surface patterns, but I still have to decide what to do about them.

What they are: tireless, consistent, and cheap. They don’t take sick days. They don’t get bored of repetitive tasks. They execute the same process at 3am on a Sunday as they do at 9am on a Monday.

The value isn’t in replacing human judgment. It’s in removing human judgment from the parts of the operation where it isn’t needed — the routine, the repetitive, the schedulable — so I can use my judgment where it actually matters.

That’s what treating AI as a co-worker means. Not AI as a magic answer machine. AI as the part of the team that handles the work that doesn’t need me.

Frequently Asked Questions

What is OpenClaw?

OpenClaw is a custom webhook server that coordinates publishing between AI workflows and GitHub repositories. When an n8n workflow generates content, it sends a JSON payload to OpenClaw, which handles file writing, git commits, GitHub pushes, and deployment notifications — enabling fully automated publishing across multiple sites from a single API call.

How much does a self-hosted AI automation stack cost per month?

Running 10 projects with daily AI-generated content costs approximately €26–30/month: €15 for a Hetzner CX32 VPS running n8n, LiteLLM, Umami, Listmonk, and Minio via Coolify, plus roughly €13/month in LLM API costs (Groq, Gemini, Anthropic). Netlify and Vercel hosting are on free tiers.

What is LiteLLM and why use it?

LiteLLM is a proxy layer between your applications and multiple LLM APIs. It enables model-agnostic code (swap providers without changing applications), unified cost tracking across projects, rate limiting, and automatic fallback routing. For anyone using more than one LLM provider, it’s essential infrastructure.

Is Coolify worth it for self-hosting?

For solo operators and small teams, Coolify makes self-hosting practical. It replaces ~€80–110/month in managed services (n8n, analytics, email, storage) with €15/month on a Hetzner VPS. Setup takes a few hours; ongoing maintenance is roughly 30 minutes per month.

What’s the difference between using AI as a tool vs AI as a co-worker?

Using AI as a tool means using it reactively — asking questions, generating drafts, reviewing outputs. Using AI as a co-worker means designing autonomous processes: AI agents that run on schedules, make decisions within defined parameters, and complete tasks without waiting for a human prompt. The distinction changes what you build and how you invest in infrastructure.