90% of the AI Agents Clients Ask For Are Just a Cron Job and One API Call

A founder asked me to build an autonomous AI agent that monitors their reviews around the clock.

I nodded, asked what the agent should actually do, and listened.

Every hour, someone needs to read the new Google reviews. The negative ones must reach the founder fast. That is the whole job.

Here is what I shipped.

A cron job. One LLM call per review. A Slack webhook.

That is it. No agent framework. No elaborate reasoning loop. No vector database. No memory store.

Every hour, the job pulls reviews posted since the last run. Each review goes to the model exactly once with one instruction: summarize this and flag it if it is negative. The negative ones land in the founder's Slack channel. Everything else gets logged and ignored.

It runs perfectly, costs almost nothing, and the founder loves it.

The whole system

One cron line:

0 * * * * /usr/bin/node /home/app/review-watch.js

One small script:

// review-watch.js: read new reviews, flag the bad ones, ping Slack
import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function main() {
  const since = new Date(Date.now() - 60 * 60 * 1000).toISOString();
  const reviews = await fetchNewReviews(since); // your reviews API here

  for (const review of reviews) {
    const verdict = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        {
          role: "system",
          content: "Classify this review as positive, neutral or negative. Reply with one word, then a one line summary.",
        },
        { role: "user", content: review.text },
      ],
    });

    const [label, summary] = verdict.choices[0].message.content.split("\n");

    if (label.trim().toLowerCase() === "negative") {
      await postToSlack(`Negative review from ${review.author}: ${summary}`);
    }
  }
}

async function postToSlack(text) {
  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text }),
  });
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

Two moving parts. You can read the entire system in one sitting.

Why this beat the agent

An agent would have added a planning loop, tool definitions, retry orchestration and state management. For what? The input is fixed: new reviews. The schedule is fixed: every hour. The output is fixed: a Slack message for the bad ones. There is no branching decision to make, no tool to choose, no memory to carry between runs.

Every layer an agent adds on top of that is a layer you get to debug at 3am. A script fails in obvious ways: the cron log tells you exactly which line broke. An agent fails in interesting ways: a tool call went sideways three steps deep inside a reasoning chain and nobody can reproduce it.

Selling an agent when a script would do is how projects get slow and expensive.

The honest framework

Build the agent when the job has real decision making:

• The system must choose between tools based on what it reads
• The path branches on intermediate results, not on fixed rules
• It needs memory across steps to finish a single task
• The input is ambiguous enough that one fixed prompt cannot handle it

Ship the script when the job looks like this:

• It runs on a schedule or on a trigger
• The inputs are known and the outputs are known
• The model does one well defined thing, like classify or summarize
• You can read the whole system in one file

Most of the agent requests I get land in the second list. That is not a failure of ambition. It is good engineering: the simplest system that does the job.

One note on cost

This runs one small model call per review, once an hour. There is no framework overhead, no repeated reasoning passes, no state store to maintain. The bill is a rounding error and the founder has never once asked what it costs. Compare that to an agent looping through a large model for the same hourly job and the difference pays for itself.

What is the most overbuilt "AI agent" you have seen? Or built? Drop it in the comments.

I'm Sohail Khan, a Senior Full Stack Developer building AI agents and automation. Tech Lead at LoopxCorp. I write about backend engineering, AI integration and practical system design.