The AI Pit Crew: Autonomous Agents Running Our Website

Three months ago we launched our site and there was my son in the doorway again.

Same posture. Same laptop under the arm. Same look of a man preparing to file a grievance.

I kept working on my laptop.

“Dad, this is too much work”

He did not give any explanation or context. Just exhaustion wearing a hoodie.

He sat into the chair, and opened his laptop. He showed me how he build a nice overview of all the products in an Excel spreadsheet. With rows of products, prices, affiliate links. Some cells glowed yellow. Some cells glowed angry yellow, while others were grey.

“Coolblue again changed prices on six pedal sets. And Bol.com? They stopped selling two wheels I just reviewed last month. This morning I read that there’s a new firmware update for the Fanatec DD Pro that changes everything I wrote about force feedback.”

He scrolled down. The yellow kept going. “And that’s just this week.”

I took a sip of my coffee. It had gone cold sometime around time I started working on my second Jira issue of the morning. “Well I am not going to tell you, I told you so…”

He didn’t laugh. “No, seriously. I started writing about Verstappen’s setup. I was planning to reach out to that Twitch streamer. Instead I spent four hours updating prices and fixing broken links. Four hours, Dad.”

The site was alive. That was the problem.

A static website for say a personal portfolio doesn’t demand anything besides the update once in a while when your experience grows or you finish a project.

Our site is not static, it contains several tools, calculators, partner integrations, news sections, and a product database that contains around 500 items across multiple retailers.

This means maintenance, you need to keep the platform up to date. It does need constant feeding of new content.

This means that you have to note every price change. Every discontinued SKU. Every piece of news from the sim racing world that our audience might care about. The work wasn’t hard, exactly. It was just a lot.

A steady drip of small tasks that, left unattended, would slowly poison everything we’d built.

He closed the laptop. “I thought the AI stuff was supposed to make this easier.”

And there it was.

He was right, of course. We’d used AI to build the site. Claude Code had helped us architect the whole thing, specifications, code, tools, the lot. But once it was live, we did not use AI anymore. We treated it like a hit-and-run consultant.

Now we were stuck doing our own plumbing.

I leaned back and looked at the spreadsheet again. “What if,” I said, “the AI didn’t leave?” He looked up.

“What if we built a team that just… stayed? Not scripts. Not automations. Actual agents. Each one watching something specific. Each one making decisions. Each one doing the work you’re drowning in right now.”

He frowned. “Like employees?”

“More like a pit crew.”

I knew this metaphor would work as we use these a lot in our family. Just like race drivers dont change their own tires. They focus on driving. All the other stuff is handled by specialist who know exactly what to do.

That was the missing piece. We’d built a race car. Now we needed the crew.

He opened the laptop again, slower this time. “So these agents would just… run? On their own?”

“They’d watch. They’d decide. They’d act. You’d get a report. You’d stay in control. But the grunt work? That’s not yours anymore.”

He stared at the spreadsheet. The angry yellow cells stared back.

“Okay,” he said. “Lets Go!”

Agency

I pushed my cold my coffee off my desk and pulled up a chair next to him.

“Before we start, you need to understand Agency.” He gave me the look. The one that says here comes the lecture.

“No, it is not a company and not a spy thriller. It means the how much an agent can act on its own. Make decisions. Take initiative without being told exactly what to do.”

I pointed at his spreadsheet. “Right now, it has zero agency. It just sits there. You are responsible for checking the prices. You decide what needs to change. You do everything. The spreadsheet is a tool. You are the agent.”

“I know, four hours”

“Now imagine a simple program. It runs every morning at six, pulls prices from CoolBlue, Bol.com, Fanatec, and updates the prices. That’s a tiny bit of agency. It acts without you pressing a button. But it can’t think. If it retrieves garbage, it writes garbage. If a product disappears, it breaks.”

“Okay, he said, so we have to make it smarter?”

“Exactly. We give it more agency. Now it doesn’t just pull prices. It checks whether the API response makes sense. If a price drops by 90%, it flags it instead of blindly updating. If a product vanishes, it marks it for review instead of crashing.”

He leaned forward. “So why not give it all the agency? Let it handle everything. Decisions, updates, the lot. Full autopilot.”

I smiled. There it was. The question everyone asks.

“Because agency is a tradeoff.”

I grabbed a pen and drew a simple line on the back of an envelope. Low agency on the left, high agency on the right.

“Down here, you have scripts. Predictable. Boring. They do exactly what you tell them, nothing more. You stay in control, but you’re still doing most of the thinking.”

I tapped the other end.

“Up here, you have full autonomy. The agent observes, reasons, decides, and acts. It handles edge cases you never anticipated. It surprises you with solutions.” “Sounds perfect.”

Ok, but there is a catch. If you give a system more agency, the more instable it becomes.

He frowned. “Why?”

“Because increased agency means it can do more on its own. When you let an agent make real decisions, it might make different decisions than you would. Sometimes better. Sometimes worse. Sometimes just… different. And when you’re running a business, ‘different’ can be expensive.”

I pointed back at the spreadsheet. “If an agent decides a price change isn’t significant and skips the update, but a customer notices the wrong price , that’s on us. If it decides a news article isn’t relevant and skips it, but it turns out to be the biggest story of the week , that’s on us.”

He sat back. “So we can’t trust them.”

“No. We trust them with the right things. That’s the art. You don’t give a junior mechanic the keys to the whole garage on day one. You give them specific responsibilities. Well-defined limits. You let them prove themselves.”

The racing metaphor clicked. I could see it in his eyes. “Each agent in our pit crew gets a defined role. Enough agency to be useful. Enough constraints to be reliable. We decide, for each one, where on that line it sits.”

His expression changed and he looked at the spreadsheet again which hadn’t changed.

“Lets start! Which one do we build first?”

Spotter — The price watcher

“So what takes you the most time?” He did not even hesitate, “Prices”

Makes sense, all of the retailers we partner with, like Coolblue, Bol.com, Fanatec, Moza, and another half a dozen update their prices constantly. Black friday, sales launch, etc.

“We need someone that watches this for you”. He looked up. “Like a spotter?” Exactly like a spotter, just like in racing where the spotter sits above the track seeing that the driver cant. Our spotter would do the same, watching all the retailers and automatically updating each products price of our site.

“So I just… stop checking?”

“That’s the idea.”

We started simple. Every morning at 4 AM, before we wake up, Spotter pulls prices from every partner. Larger retailers such as Coolblue and Bol.com offer an API or use an intermediary like Awin.com that provides an API.

Some partners don’t provide anything, they just tell you have to create an affiliate link and you just have to get the prices by scraping their website.

Especially the scraping has been tedious, and error prone. Spotter runs every morning through a GitHub action. When trying to scrape prices using an IP address that comes from a big data centre most websites block you.

We tried stealth libraries designed to make scrapers look like real browsers. Sometimes they worked. Sometimes the retailer updated their detection and we’d wake up to empty data.

Spotter has almost no agency. It doesn’t make decisions. It just follows rules. Pull prices, parse data, update the markdown of the products.

There’s one exception. When parsing does not succeed, Spotter sends the HTML to an LLM. We use OpenAI’s GPT OSS 120B through Groq. Fast, cheap, and good enough for extracting a price from messy HTML.

Every morning at 4 AM, after the run, Spotter posts to Slack. Eight prices updated, one scrape failed, 88 unchanged. The Fanatec wheelbase went up €7. The Playseat dropped €12. A Thrustmaster pack increased by €40, probably a sale ended.

And that failure? Fanatec changed their page again. Spotter flagged it. I have to change the scraper to fix it.

My son hasn’t opened his spreadsheet in months.

Radio — The news section

Spotter was a success, so it did not take long for my son to come with a new request.

“Dad, a lot of our competitors have daily news sections regarding sim racing. It would be cool if could have also such a section on the website. But, I wont have to time to write such articles. Could we do the same as we did with Spotter?”

I leaned back. “It’s different. We can’t generate news from nothing.”

He looked disappointed.

“But… we can collect it. Summarize it. Translate it for our Dutch audience. Link back to the source for anyone who wants the full story.”

“Sounds great, lets do it”

Spotter just watches numbers, but Radio uses 14 different RSS feeds to get news, split into two tiers. Tier A are the official announcements from hardware sources such as Moza, Fanatec, and Sim-lab. Tier B are news outlets such as Traxion.gg, GTPlanet, and Bsimracing.

“But won’t we get the same story from five different sites?”

That is one problem we have to fix. When Fanatec announces and it hits Reddit, then all the other news outlets will pick it up. Without deduplication, our news section would be a mess of repeats.

So Radio checks. First, obvious URL matches. Then title similarity. And when that’s not enough, it asks the LLM: “Are these two stories about the same thing?”

Once it knows what’s actually new, it summarizes it into 35 to 55 words, translated to Dutch and links back to the original. We’re not copying anyone’s work. We’re pointing our readers toward it.

Every morning at 5:15, Radio reports in. Mondays, it starts a fresh week.

Some days it finds nothing. And on other days there’s a Fanatec announcement and there are five outlets covering it. Radio deduplicates it down to one summary with the best source linked.

Like Spotter, Radio uses OpenAI’s GPT OSS 120B through Groq. Fast and cheap.

My son checks the news section maybe once a week now. Just to see what’s been happening in his own hobby. If you’re curious, so can you: https://mysimrig.nl/en/news

Scrutineer — The hyper link validator

“Dad, someone commented that a link in my latest review was broken.”

He showed me the comment. A reader clicked through to a product page, and got a 404. The retailer had restructured their URLs months ago. We never noticed.

“How many others are broken?”

He shrugged. “No idea. I’m not going to click through all the 500 products to find out.”

So we build Scrutineer. In racing, a scrutineer is responsible for inspecting racing vehicle to ensure compliance with regulations and safety standards

Ours does the same. Scrutineer runs every Sunday night. It crawls every page on the site, blog posts, product pages, tools and checks every link, internal and external.

Sunday morning, we get a Slack report. Usually empty. Sometimes a retailer changed their URL structure, or we mistyped an internal link. Either way, we know before readers do.

No agency at all. Just: does this URL return 200 or not? If not, flag it.

The Newsroom — Content generation

“Dad, I have a crazy idea.”

He closed his laptop and looked at me. That usually means he’s been thinking about something for a while.

“What if we didn’t just automatically update prices and create news summaries? What if we start with writing content? Automatically?”

I looked up. “You want AI to write our blog posts?”

“Yes, No. I read something about letting multiple AI agents work together. So we create one that finds interesting topics. One that writes a draft. Another one edits. The next one checks the facts. One adds the affiliate links. The last one makes the Instagram reel.”

“So not one agent writing a post,” I said. “Six agents, each with a role.”

“Exactly.” He grinned. “An agent pipeline.”

“But nothing publishes without you looking at it.”

He nodded. “That’s the line. The agents prepare everything overnight. By 8 AM, there’s a draft waiting. I read it, tweak it, approve it. Or kill it.”

“So you’re still the editor.”

“Editor-in-chief.” He smiled. “They’re my staff.”

So we mapped every function to an AI agent. Each agent runs in sequence overnight on a raspberry PI in the corner of my home office. To prevent the scraping issues we have with Spotter we decided to use a Raspberry PI.

Scout

Scout is the first agent, it wakes up at midnight. It scans several sim racing forums like Reddit, Tweakers, iRacing forums, and RaceDepartment. It looks for topics that the sim racing community is talking about. It selects the most promising (active ones) and hands them off to Archie.

Archie

Archie takes over at 00:45. It receives the selected topics from Scout and researches each one, web searches, and pulling relevant products from our catalog. Then it writes a first draft using DeepSeek V3 and generates a cover image via Fal.ai One less thing for my son to create manually. The rough draft goes to Emma.

Emma

Emma is the tone editor. Every site has a voice. Ours is described in a style guide as “a cynical, witty tech blogger with battle scars from the trenches.” Emma reads each draft and rewrites it to match that voice. The same facts, different personality. She passes the polished draft to Victor.

Victor

Victor is the fact-checker. He reads both the Dutch and English versions and validates every claim. Using DeepSeek’s tool-calling with Tavily web search, he verifies prices, release dates, specs. Anything that could be wrong. When he’s confident, he corrects. When he’s unsure, he flags it for human review. Then he hands off to Luna.

Luna

Luna handles the business side. She scans the article for product mentions and inserts affiliate links from our catalog. Then she scores the article across six dimensions: content depth, topic freshness, keyword coverage, affiliate potential, readability, and media quality. The weighted score tells us how good this draft really is. Luna marks the article as ready for review and passes it to Max.

Max

Max is the closer. He takes the finished article and creates the social media presence. It creates an Instagram caption in Dutch and English, and a video reel. The reel gets an AI voiceover from ElevenLabs, Ken Burns effects on the images, subtitles, and background music mixed in via FFmpeg. Max schedules everything through the Later API, ready to post after approval.

By 7 AM, the pipeline is done. By 8 AM, my son wakes up to a draft blog post, a matching Instagram reel, and a quality score.

He looked at the dashboard one morning. Six agents, all green. A draft waiting with a score of 84.

“I didn’t do anything,” he said.

“That’s the point.”

He still reviews every post. Still tweaks the wording, catches the occasional weird phrasing, kills the drafts that don’t feel right. He’s the editor-in-chief, not a rubber stamp.

But the four hours he used to spend writing? Now he spends them reaching out to that Twitch streamer. Recording interviews with sim racers. Actually growing the site instead of just maintaining it.

The agents gave him his weekends back. Just like we promised.

What still breaks

The crew isn’t perfect. They’re junior employees, and junior employees make mistakes.

Luna’s internal link insertion still doesn’t work reliably. She’s supposed to find product mentions and link them to our catalog, but half the time she misses them or links to the wrong product. We’re not sure why. For now, my son still adds those links manually.

Max is the most complex agent, and complexity means fragility. The reels look good, sometimes surprisingly good. But the voiceover trips over our own name. ElevenLabs pronounces “mysimrig.nl” as gibberish. If we spell it “mysimrig dot nl” in the script, the voice gets it right, but then Max sometimes puts “dot nl” in the subtitles too. We’re still tuning that.

And Scrutineer? It works perfectly. It just takes almost two hours to crawl the entire site on a Raspberry Pi. We run it Sunday nights and hope nothing urgent breaks on a Tuesday.

What we learned

Building this crew took almost months. Not because the code was hard. Most agents are a few hundred lines of Python or TypeScript. The hard part was calibration. Finding the right level of agency for each role. Learning when to trust the output and when to add a guardrail.

The agents aren’t replacing my son. They’re handling the grunt work so he can focus on the parts that actually need a human like the interviews, the collaborations, the creative decisions that make MySimRig more than just another affiliate site.

Two months ago, he stood in the doorway, exhausted, spreadsheet glowing yellow.

Now he checks Slack over coffee, approves a draft, and spends his afternoon reaching out to that Twitch streamer he never had time for.

The pit crew made that possible.

If you want to see what they produce, visit mysimrig.nl. And if you build your own crew, let us know. We’re still learning too.

Under the hood

If you are looking to build your own crew with AI Agents, here is what’s what we used for the implementation.

The stack

• Raspberry Pi 4 Model B (4GB RAM, Debian)
• Python 3.12, TypeScript / NodeJS
• DeepSeek V3.2 via OpenAI SDK
• Groq (GPT OSS 120B) for fast, cheap inference
• SQLite message queue for agent communication
• Tavily for web search (fact-checking)
• ElevenLabs for voiceovers
• Fal.ai for image and video generation
• FFmpeg for video composition
• GitHub Actions (Spotter, Radio, Scrutineer)

We dont use a Agent framework like langchain or autogen. Although these are excellent frameworks they felt overkill for this implementation. The agents are triggered using cron jobs on the PI or via a GitHub action trigger.

The orchestration

The source code of each agent is in its own git repository. They communicate with each other via a simple message queue implemented using a single SQLite messages table. When an agent finishes it sends a message to the next agent in line.

def _send_digest_to_archie(settings, content_opportunities) -> None: 
  queue = PipelineQueue(settings.pipeline_db_path) 
  queue.connect() 
 
  thread_id = create_thread_id("topic") 
  queue.update_status(settings.agent_name, "sending_digest", thread_id) 
 
  top_opportunities = content_opportunities[:5] 
  opportunities_data = [ 
    { 
      "question": opp.question, 
      "frequency": opp.frequency, 
      "reasoning": opp.reasoning, 
    } 
    for opp in top_opportunities 
  ] 
 
  body = json.dumps({ 
    "type": "topic_digest", 
    "thread_id": thread_id, 
    "opportunity_count": len(content_opportunities), 
    "opportunities": opportunities_data, 
  }, indent=2) 
 
  queue.send( 
    from_agent=settings.agent_name, 
    to_agent=settings.recipient_agent, 
    subject=f"Topic Digest: {len(content_opportunities)} opportunities", 
    body=body, 
    thread_id=thread_id, 
  ) 
 
  queue.mark_success(settings.agent_name) 
  queue.close()

We did not need any fancy orchestration. Each agent just wakes up via cron, does its job and passes the stick.

The prompts

Here is a small part of Archie’s prompt for article generation. This is the prompt that turns the community interest signal into a draft blog post:

You are an expert sim racing content writer for MySimRig... 
 
## Content Opportunity 
Question: {question} 
Frequency: {frequency} mentions in community discussions 
Analysis: {reasoning} 
 
## Requirements 
- Write in a helpful, conversational tone 
- Reference specific products with their current prices 
- Generate BOTH Dutch and English versions 
- Create a prompt for the hero image 
 
## Output Format 
Respond with valid JSON: 
{ 
    "slug": "shared-article-slug", 
    "dutch": { "title": "...", "content": "..." }, 
    "english": { "title": "...", "content": "..." }, 
    "image_prompt": "..." 
}

It is a single prompt that generates drafts for both languages. It also includes the image prompt. The LLM performs the heavy lifting and the agent handles the plumbing.

The costs

The costs differ per month and depends on how many community signals we receive. Below the average per month of the last 3 months.

Groq: $0.25/month
DeepSeek: ~$0.40/month
ElevenLabs: $5/month (starter)
Fal.ai: ~$4/month (with video)
Tavily: Free tier
Raspberry Pi: Already owned 
Total: ~$10/month

Previously my son uses to spend 10 hours per week on maintenance. He was updating prices, creating news summaries, checking links, creating content and social posts. The Instagram reels alone used to take 6 hours each for finding clips, writing scripts, editing, adding subtitles, mixing audio using DaVinci Resolve

Now? They’re generated overnight. He still spends about 10 hours a week on the site. But the work is different.

Instead of updating spreadsheets, he’s interviewing sim racers. Instead of hunting for broken links, he’s sketching ideas for new tools. Instead of editing reels frame by frame, he’s reviewing drafts and approving posts.

The agents didn’t give him free time. They gave him his time back.

The tradeoff

Our setup won’t win any IT architecture awards. SQLite isn’t a “real” message queue. The Pi is slow. The agents are simple scripts, not sophisticated reasoning systems.

But it works. It costs less than a Netflix subscription. And it gave us our weekends back.

If you’re running a content site and drowning in maintenance, you don’t need a complex framework. You need a few scripts that wake up at midnight and do the boring work while you sleep.

Start with one agent. Solve one problem. See what happens.