The $44 Agent Stack | Make It Ryne

Step 1

Rent the box

Hetzner CPX11: 2 vCPU, 2GB RAM, $4.99/mo

Agents idle 95% of the day. They wake up, make an API call, write a row, and go back to sleep. That workload does not need a cluster. It needs the smallest VPS Hetzner sells. Create a CPX11, SSH in, install Docker, and define the whole stack in one compose file:

# docker-compose.yml
services:
  postgres:
    image: postgres:16
    volumes: ["pgdata:/var/lib/postgresql/data"]
    environment:
      POSTGRES_DB: ops
      POSTGRES_PASSWORD: ${DB_PASS}
  agents:
    build: .
    env_file: .env
    depends_on: [postgres]
volumes:
  pgdata:

Your deploy process from here on is git push and docker compose up -d --build. That's the whole DevOps department.

Step 2

Give the team a shared brain

Postgres, already running. Replaces a $300/mo CRM.

The single biggest multi-agent mistake: letting each agent trust its own context window. Context windows forget. Tables don't. Every agent reads and writes the same five tables, so a handoff is a query, not a meeting:

CREATE TABLE leads   (id serial, email text, score real,
                      status text, notes jsonb, updated_at timestamptz);
CREATE TABLE tickets (id serial, from_email text, status text,
                      thread jsonb, resolved_at timestamptz);
CREATE TABLE orders  (id serial, product text, amount int,
                      status text, delivered_at timestamptz);
CREATE TABLE jobs    (id serial, agent text, payload jsonb,
                      status text DEFAULT 'queued');
CREATE TABLE memory  (agent text, key text, value jsonb,
                      PRIMARY KEY (agent, key));

Every action any agent takes lands in a row. When the sales agent qualifies a lead and the delivery agent later ships that client's order, neither one needed to talk to the other. They both just read the table.

Step 3

Wire the orchestrator

$0. Cron plus a queue beats LangChain.

You don't need an orchestration framework. You need three cron lines and a worker that pulls from the jobs table:

# crontab -e
*/5 * * * * node poll-inbox.mjs      # mail → jobs table
0 8 * * *   node agents/sales.mjs    # daily batch
* * * * *   node queue-worker.mjs    # drain the queue

The worker is 30 lines: claim the oldest queued job with FOR UPDATE SKIP LOCKED, run the matching agent, mark it done or failed. Failed jobs stay in the table where you can see them. That visibility is worth more than any framework feature.

Step 4

Ship the sales agent

Replaces a $6k/mo SDR. About $0.04 per 50-lead batch.

The cost rule that makes the whole system cheap: Haiku scores, Sonnet only writes. Scoring 50 leads against your ICP is a classification job, so it goes to claude-haiku-4-5. Only the handful that clear a 0.7 score earn a Sonnet-drafted email:

// agents/sales.mjs (core loop)
const score = await claude("claude-haiku-4-5",
  `Score this lead 0-1 against my ICP: ${icp}
   Lead: ${JSON.stringify(lead)}
   Reply with JSON: {"score": n, "why": "..."}`)

if (score > 0.7) {
  const draft = await claude("claude-sonnet-4-5",
    `Write a 3-sentence first-touch email. No fluff,
     one specific observation about their business,
     one clear ask. Lead: ${JSON.stringify(lead)}`)
  await resend.emails.send({ ...draft, scheduledAt: "in 1 hour" })
}
await db.query("UPDATE leads SET score=$1, status=$2 ...")

Sending goes through Resend, whose free tier covers a solo operation's outbound volume. Cron fires this at 8am. Qualified leads are scored, drafted, and queued before you're awake.

Step 5

Ship the support agent

Replaces a support rep. Haiku again.

Support is where people over-engineer. The agent itself is simple: poll the inbox every 60 seconds, answer from your docs, and give it real tools so it can touch the orders database instead of guessing. The part that IS the product is the escalation config:

# agents/support.yaml
model: claude-haiku-4-5
inbox: support@yourdomain.com   # poll every 60s
tools: [orders_db, refunds, kb]
escalate:
  - refund_over: 200        # money decisions → you
  - anger_signals: 2        # twice angry → you
  - no_kb_match: true       # unknown territory → you

Spend an hour writing those rules and revisit them weekly. Agents resolve the routine tickets in minutes. Edge cases hit you, and only edge cases. Run it under pm2 so it survives crashes, and read pm2 logs support with your morning coffee.

Step 6

Ship the delivery agent

Replaces an ops coordinator. Sonnet earns its keep here.

This only works if you sell fixed scope: an audit report, a setup package, a defined deliverable at a defined price. Agents love scope. Open-ended consulting breaks them. With a fixed product, the pipeline is: intake form parsed, draft written by claude-sonnet-4-5, anything sensitive flagged for your review, PDF built and branded, sent to the client, invoice marked paid in the orders table.

node agents/delivery.mjs --job 218
# ✓ Intake parsed → drafted → pricing flagged
# ✓ PDF built → sent → order closed

You are not out of the loop. You're the reviewer of flagged sections and the spot-checker of finished work. That's a 10-minute job per order instead of a 4-hour one.

Step 7

Meter everything

The API is roughly 70% of your bill. Watch it.

Write a status.mjs that prints jobs per agent over 24 hours and the error count. Run it every morning. Then log token usage per API call into the database, because the Claude API returns usage numbers on every response and the API line item is the one bill that can actually move on you:

await db.query(
  `INSERT INTO memory (agent, key, value)
   VALUES ($1, 'usage', $2)`,
  [agent, JSON.stringify(response.usage)])

For reference, a full production month of this system: server $4.99, Claude API $31.40, Resend free, Twilio SMS $6.20, domain $1.25. Total $43.84. If your API bill spikes, the fix is almost always the same: something is calling Sonnet that should be calling Haiku.

The $44/mo AI operation

What you'll have when you're done