【Complete Guide】How to Build an AI Agent That Runs 24/7
Think fully automated AI agents are still a pipe dream? Well, they're actually achievable. The truth is, most AI agents fail because of "design traps." I personally tried to automate everything from the start, built about 40 agents, and watched them spectacularly crash 😂. But recently, I tried the "how to build an AI agent that runs 24/7" approach that's been spreading overseas, and it actually delivered real results. This time, I'm breaking down the design methodology for building AI agents that are hard to break and run continuously 💖
"Build an AI agent that works while I sleep" — that's the dream, right?
I thought the same thing at first.
Waking up to X post drafts already written. AI news summarized and delivered to Slack. Commit logs neatly organized.
That future has to exist, right?
Turns out, six months ago I was a "non-coder humanities major" who just started tinkering with Claude Code. I immediately built about 40 agents in parallel — a leader role, writer role, researcher role, quality checker role, editor role… I was literally drawing an org chart in my head.
Three hours later, total collapse 😂😂😂
That's when I first realized: "Building an AI agent" and "keeping an AI agent running" are two completely different things.
Turns out, there's been a trending story among Claude Code users called "I built 40 agents and quit them all" — and I had done exactly the same thing. Around the same time, a developer named Nate Herk published an incredible article comparing "all three deployment methods I tested." Reading it made everything click for me.
Today, I'm laying out everything I learned — from crashing 40 agents, to devouring Nate Herk's article, to testing everything myself — to give you the complete guide on how to build AI agents that don't break and run 24/7 💖
By the end of this, you'll understand:
- Why your agents break — structurally
- The differences between /loop / Routines / Modal / [Trigger.dev](//Trigger.dev) / Agent SDK / Managed Agents
- A decision flow for when to use which
- How to use Hook (the heart of unbreakable design)
- How to never repeat the cycle of building 40 agents and scrapping them all
I've broken everything down so even a "non-coder humanities major" like me can understand it, so read with confidence.
Let's win together ✨
■ So Why Did 40 Agents Crash?
Let me start with what I actually did wrong.
The first week felt like pure magic.
I'd say, "A (research lead), look into this," "B (writer), draft based on A's findings," "C (checker), quality-check B's draft" — just calling agents in sequence while I gave instructions.
I'd go grab coffee, come back, and three drafts would be ready.
Isn't that god-tier??
But around week two, things started going wrong.
"Wait, B was supposed to write that draft… but A wrote it?"
"C was supposed to check it, but they're saying the same thing as B…"
"And wait, where did D go? I built them first…"
By week three, I couldn't even track what was happening anymore.
And after a month, I quit all 40 agents.
Turns out, someone had already shared a similar experience. Kohaku (@Kohaku\_NFT) wrote a note called "I Built 40 AI Employees and Quit Them All in a Month" — and it hit hard. It matched my experience perfectly.
It outlined three structural reasons why agents break. And this wasn't just my gut feeling — it's documented in Anthropic's official docs too.
Reason 1: Context Rot
If you've used Claude Code, you've definitely hit this trap at least once.
Claude has a context window — a limit on how much information it can process simultaneously. Anthropic's official docs state:
*As token count increases, the model's ability to accurately recall information from that context decreases.*
"Can handle 1 million tokens" and "runs stably with 1 million tokens" are completely different things.
In practice, output starts to drift around 100K tokens. Running 40 agents means each one accumulates history, and the window fills up fast. Then they forget instructions you just gave, stop following rules, and start contradicting past interactions.
That's context rot.
I thought "more rules will make it better" and kept adding them — but the more I added, the more it broke. More rules create conflicts and accelerate context rot.
Completely counterproductive 😂😂😂
Reason 2: Compaction Collapse
Claude Code has a feature called "Compaction." When the context gets full, it summarizes past conversations to free up space for new ones.
Sounds great in theory, but when summaries of summaries pile up, they degrade into noise.
With my 40 agents, this happened:
"Three people disappeared, two duplicated, and the remaining 35 didn't notice."
That golden line from Kohaku's note was exactly what happened. After compaction ran, agents would be like, "Wait, who's here and who's not?" Consistency breaks. But 35 agents keep running like nothing happened.
Run it for three hours, and it would almost certainly collapse.
Reason 3: Text Rules Aren't Absolute Commands
This was the biggest blind spot.
I always thought, "If I write rules, they'll follow them." I wrote incredibly detailed rules in CLAUDE.md and agent definitions.
But for an LLM, rule text is just part of the context. It gets pulled by recent interactions, mid-process instructions, and current context — causing interpretation drift.
"Prohibited" gets executed anyway. "Always" gets skipped.
With 40 agents running in parallel, each one starts operating with slightly different interpretations. That was another cause of failure.
So my 40 agents didn't break from operational mistakes — they were built on a fundamentally fragile structure from the start.
Now for the main event: how to build a non-fragile structure.
■ The 3 Foundations of Unbreakable Agents (WAT Framework)
Reading Nate Herk's article, I had a moment where everything clicked.
It's called the WAT Framework.
WAT stands for:
- W = Workflow (the procedure)
- A = Agent (the thinking part)
- T = Tools (the execution part)
When we say "build an AI agent," we tend to unconsciously mix these three together. But treating them as separate things is the golden rule for unbreakable agents.
Workflow
This is the deterministic part — what to do and in what order.
For example: "Every morning at 9 AM, fetch X mentions → summarize → send to Slack."
No AI judgment needed here. The order is fixed, so just run it as programmed.
Agent
This is where AI shines.
"Think of a contextually appropriate reply to this user mention" or "Write an article draft from this research." Only delegate the parts that need judgment, reasoning, and creativity to AI.
Tools
Calling X's API, writing to files, sending to Slack, generating images. These need deterministic behavior, so lock them down with code.
Since you don't want AI to "get clever and do something weird," the trick is to strictly limit what AI can touch in your tools.
The reason things break: mixing these three together
When I built 40 agents, I was making everything an Agent.
I thought, "Research, writing, quality check — just let AI decide everything."
That was wrong.
Implement the parts that need judgment (Agent), the fixed procedures (Workflow), and the deterministic actions (Tools) in separate layers. That's the foundation of unbreakable design.
By the way, thinking in WAT makes deployment choices much clearer.
You decide what to deploy where.
Some methods can carry all of WAT. Others carry only W and T, losing A. Being aware of this helps you see which method fits your use case.
Now let's go through all six methods for running agents 24/7.
■ Method 1: /loop (Quick Bot Running in Terminal)
Starting with the easiest one.
Claude Code has a feature called /loop, and it's the best starting point for automation.
Super simple to use.
Just open Claude Code and say:
*"Create a loop that reads new comments every 10 minutes and uses the transcript to think of replies."*
That's it. Claude Code will use a tool called cron create in the background to set up the schedule automatically.
How it works: The cron trio
Three tools run in the background:
- cron create (schedule creation)
- cron list (check running schedules)
- cron delete (delete)
The scheduler runs inside Claude Code's process, independent per session. So you can run five different loops in five terminals simultaneously without interference (as long as they don't write to the same file).
Terminal vs Desktop behavior differs
This was a "wait, really?!" moment from Nate Herk's article.
If you run /loop in the desktop app and type /clear, the cron dies.
But in the terminal version, /clear doesn't kill the cron.
This is a surprisingly huge difference.
When you run a long loop, context fills up, right? You want to refresh it with /clear, but if the cron dies too, it's pointless.
With the terminal version, you clear only the context while the cron keeps running.
The genius trick I loved: embedding /clear inside the loop
This is Nate Herk's original trick, and I thought it was pure genius.
In the terminal, create two loops:
- Loop A: Does the actual work every 10 minutes
- Loop B: Injects /clear as a slash command every 5 minutes
Wait, can cron run slash commands? Yes, it can 😂😂😂
While Loop A's work runs in the background, Loop B resets the context every 5 minutes. It automatically refreshes before context rot sets in.
When I learned this, I almost fell out of my chair. Isn't that god-tier??
/loop's weaknesses (what you should know)
But there are caveats.
- Closing your PC stops the loop (since it runs locally)
- Closing the session ends it
- The terminal version expires in about 7 days max, the desktop version in about 3 days max (official docs don't give exact numbers, so these are rough)
- Even if you set it to "every 10 minutes," it won't run exactly at 10:10:00 — there's a drift of a few minutes. This is intentional, to prevent all Claude Code sessions from hitting Anthropic's API at the exact same time globally
And the biggest pitfall? The retry loop.
There's a case shared on Zenn where Claude Code misread an error message and kept calling the same tool over and over, burning through 5 hours' worth of credits in 19 minutes.
No joke.
To prevent this, the Hook feature (covered later) helps. For now, if you're just using /loop, don't leave it running overnight — test it for a short period first.
In WAT terms, /loop is a deployment method that handles W, A, and T. The Agent stays alive, Tools are usable, and Workflows run. It's the strongest option for simplicity.
■ Method 2: Claude Routines (The Real Deal — Runs Even with Your PC Closed)
For me, this is the "finally, the real deal."
/loop is convenient, but you still have to keep your PC open. It won't run when you're out, and it stops if you restart your PC.
Claude Routines runs on Anthropic's cloud.
How to Use
Just open the Claude Code desktop app and select Routines.
There are two types: Local Scheduled Tasks and Remote Claude Routines.
- Local: Runs on your PC (stops when you close it)
- Remote: Runs on Anthropic's cloud (keeps running even with your PC closed)
The setup screens are nearly identical. Write a prompt, set a schedule, and save.
The prompt you write gets injected into a fresh Claude Code session on schedule, and that session executes the task.
Usage Limits (By Plan)
Since Remote Routines run on Anthropic's cloud, there's a daily execution limit per plan.
The official docs ([code.claude.com/docs/en/routines](//code.claude.com/docs/en/routines)) state:
- Pro: Up to 5 times per day
- Max 5x: Up to 15 times per day
- Max 20x: Up to 15 times per day
- Team / Enterprise: No explicit limit (may vary by plan)
Exceeding the limit incurs additional charges, so plan your frequency carefully.
Minimum Interval: 1 Hour
This is a common gotcha — the minimum interval for Routines is 1 hour.
If you want it to run every 10 minutes, cron will reject anything under an hour.
For finer granularity, you'll have to go back to /loop.
Webhooks and GitHub Events Also Work
Routines aren't just for scheduled triggers. You have three options:
- Schedule (cron)
- API endpoint (triggered externally)
- GitHub event (triggered by GitHub activity)
This means you can call Routines from other automation tools. For example, a Slack bot could trigger a Routine to have Claude do research and send back the results.
Catch-Up Feature (Subtly Important)
Local Scheduled Tasks have a "catch-up" feature, and it's a subtle trap.
If you turn off your PC for 5 days and then open it, it will run all the missed tasks from those 5 days at once.
This can be useful, but also dangerous.
For routines that *must* run at a specific time, either disable them or rethink the design.
Examples of What I Run with Routines
Here are some examples I personally run, along with success stories circulating among the Claude Code community.
One case shared on a domestic note platform:
- Every morning at 9: Auto-collect AI news from HackerNews / Reddit / official blogs → Save to Notion with timestamps → Notify on Slack (Gotcha: Network must be set to "Full" for external access)
- Every Sunday at 6 PM: Auto-generate a week's worth of X posts → Schedule posts for Mon-Sat at 7 AM / 12 PM / 7 PM (Combined with human approval — not fully automated)
- Code review while you sleep (Routines + Claude Agent SDK, covered later)
Fully cloud-based, no PC needed. This was a game-changer for me.
In WAT terms, Routines is a deployment method that handles W, A, and T. Like /loop, it uses the full Claude Code subscription features.
This is my "first real deal."
■ Method 3: Modal and [Trigger.dev](//Trigger.dev) (Fully Autonomous in the Cloud)
This is where things get a bit more advanced.
"Let's stop running inside Claude Code entirely. Move it to an external cloud and make it independent."
That's Modal and [Trigger.dev](//Trigger.dev).
Modal (Python)
Modal is a Python serverless platform. Think "write a Python function, deploy it, and trigger it with cron."
Pricing is surprisingly reasonable.
- Free Tier: $30/month in compute credits (Starter plan)
- Per-second billing (only for CPU, memory, and GPU time used)
GPU pricing examples: A10G at $0.000306/sec, A100 at $0.001036/sec, H100 at $0.002778/sec (from [modal.com/pricing](//modal.com/pricing)).
[Trigger.dev](//Trigger.dev) (TypeScript)
[Trigger.dev](//Trigger.dev) is a TypeScript durable workflow engine. It's designed for "long-running, failure-resistant workflows" more than Modal.
Pricing:
- Free: $0/month (includes $5 usage credit), 10 concurrent executions
- Hobby: $10/month (includes $10 usage), 25 concurrent
- Pro: $50/month (includes $50 usage), 100+ concurrent
Modal vs. [Trigger.dev](//Trigger.dev): Which to Choose?
Roughly:
- Want to write in Python? → Modal
- Want to write in TypeScript? → [Trigger.dev](//Trigger.dev)
- "This is a deterministic script, no AI judgment needed" → Modal is lighter
- "I want to build a long-running, agentic-like workflow" → [Trigger.dev](//Trigger.dev) is better
Both support cron triggers and external webhooks.
Key Trade-off: Losing the Agent
This is a critical point.
If you move what you were doing in Claude Code to Modal or [Trigger.dev](//Trigger.dev), you lose the Claude Code subscription.
To use AI inside, you'll need a separate Claude API key and pay per-token.
As of May 2026, Claude API pricing is (from [platform.claude.com/docs/en/about-claude/pricing](//platform.claude.com/docs/en/about-claude/pricing)):
- Claude Opus 4.7: $5 input, $25 output (per million tokens)
- Claude Sonnet 4.6: $3 input, $15 output
- Claude Haiku 4.5: $1 input, $5 output
So, a token-wasteful design could cost much more than a Claude Code subscription.
On the flip side, for deterministic scripts that don't use AI, this is the strongest option.
Think "fetch data, format it, write it to a sheet." No AI judgment needed. Put that on Modal or [Trigger.dev](//Trigger.dev) and it runs 24/7 with zero API token costs.
In WAT terms, Modal / [Trigger.dev](//Trigger.dev) is a deployment method that handles W and T, but loses A (the Agent).
Whether you can recognize "this doesn't need AI at all" is the key to keeping costs down.
■ Method 4: Claude Agent SDK (Your Own Agent Factory)
"Want to move to Modal or [Trigger.dev](//Trigger.dev), but also want to keep the Agent." That's where the Claude Agent SDK comes in.
For me, this was the moment "everything finally clicked."
It's the "underlying harness" that Claude Code normally uses, exposed as an SDK you can call from your own Python or TypeScript code.
What It Can Do
The official Agent SDK has all the same features as Claude Code:
- Subagents (calling sub-agents)
- MCP (external tool connections)
- Hook (event-driven processing)
- Skills (defining behavior for specific tasks)
- Slash commands
- CLAUDE.md (project context)
- Memory (persistent storage)
- Compaction (automatic compression)
All of it. You can embed what you were doing in Claude Code directly into your own code.
Stateless by Default
One gotcha here.
Each request in the Agent SDK is stateless by default.
If you do nothing, it starts fresh every time. It won't remember "what we were just talking about."
To make it a continuous conversation, you need to pass a session ID with each request.
session_id = "my-session-001"
# First request
response = client.query("Tell me the project status", session_id=session_id)
# Second request (same session_id to continue)
response = client.query("What about next week's tasks?", session_id=session_id)This lets Claude treat it as a continuation. Compaction runs automatically, so it can handle long sessions.
To start fresh, just use a new session_id. There's no /clear equivalent.
Pricing: Per-Token via Claude API
The Agent SDK is separate from the Claude Code subscription.
You need an API key and pay per token — same as Modal / [Trigger.dev](//Trigger.dev).
However, on May 13, 2026, Anthropic announced that Claude Code's monthly subscription credits will also be usable with the Agent SDK. This was revolutionary.
The official announcement is here (@ClaudeDevs / 2026-05-13).
Starting June 15, 2026, the new monthly credit system kicks in:
- Pro: $20/month worth of credits
- Max 5x: $100/month worth of credits
- Max 20x: $200/month worth of credits
These can be used with the Agent SDK, claude -p, Claude Code GitHub Actions, and third-party Agent SDK apps.
If you were thinking, "The Agent SDK seems expensive, so I'll skip it," this dramatically lowers the barrier.
In WAT terms, the Agent SDK can handle all of W, A, and T — and on your own infrastructure. It's the strongest option.
■ Method 5: Managed Agents (Brief Overview)
I'll mention this one too.
This is a new service from Anthropic that fully manages agents on [platform.claude.com](//platform.claude.com).
You can deploy in 4 steps, it runs in a sandbox, maintains sessions, and connects to MCP.
Honestly, though, I don't use it for my own purposes.
For people already using Claude Code, it's more natural to stay within Claude Code. Managed Agents feels like a "lightweight starter package for people who haven't opened Claude Code yet."
If you're someone who "isn't used to Claude Code but wants an agent," this might be a better fit.
In WAT terms, this is like entrusting all of W, A, and T to Anthropic. It's the easiest to get started, but you lose customization freedom.
■ Hooks (The Heart of a Resilient Design)
This is the part I've been most excited to write about today 💖
The heart of building a "resilient agent" is the Hook.
Even among people using Claude Code, many still aren't using Hooks. Such a waste.
What is a Hook?
Claude Code has various "timing points":
- Right before using a tool
- Right after using a tool
- When a session starts
- When a session ends
- When a message arrives
- Right before Compaction runs
At each of these points, a Hook is a mechanism that automatically runs a small script you've written.
Why Hooks Are the Heart of a Resilient Design
Remember the story about the 40 agents I broke? There were three reasons:
- Context corruption
- Compaction collapse
- Text rules not being followed
Hooks can structurally prevent two of these.
For example, developer Mike Dolan (DEV Community) shared a Hook like this:
*When Compaction is about to run, the Hook detects it and offloads the current task to a subagent.*
In other words, it detects that "the context is in danger" in advance and automatically hands off to another agent. A mechanism to escape before collapse.
I thought this was truly genius.
What You Can Actually Do with Hooks
Here are about five representative examples.
First: Block dangerous command execution. The Hook detects and blocks things like rm -rf or direct access to a production database. It's the last line of defense when Claude Code goes rogue.
Second: Force a Read before file writes. The Hook physically enforces the rule "read the file properly before writing." Text rules might not be followed, but with a Hook, it's absolute.
Third: Save a reflection every time a conversation ends. Use the SessionEnd Hook to automatically accumulate knowledge. This lets you leverage knowledge in the next session.
Fourth: Load necessary context at session start. Use the SessionStart Hook to load project status, past mistakes, or anything you want to read at the beginning, every time.
Fifth: Detect retry loops. This is a defense against the earlier example of "5 hours of work disappearing in 19 minutes." If the same tool call runs multiple times in a short period, the Hook stops it.
Hooks Are Just Scripts
Writing "Hook" makes it sound complicated, but it's just a script.
Node.js, Python, Bash — anything works. Claude Code just calls it at the right time.
Even someone like me, a "non-coder humanities major," started my first Hook with something like "play a notification sound when Claude finishes responding." A one-line script is still a Hook, haha.
As you build them up, they become your own personal safety net.
Instead of lamenting that "rules aren't followed," use Hooks to physically enforce them. That's the core of a resilient design.
In WAT terms, Hooks are a mechanism to insert a decisive constraint between A and T. They stop the AI from "being clever and doing weird things."
■ So, Which One Should You Choose and When? (Decision Flow)
We've looked at six methods so far.
- Method 1: /loop
- Method 2: Claude Routines
- Method 3: Modal / [Trigger.dev](//Trigger.dev)
- Method 4: Claude Agent SDK
- Method 5: Managed Agents
- Hooks (the heart you add to everything)
"So, which one should I choose?" I wondered the same thing at first.
Here's the decision framework:
1. You want a full agent loop while working live → /loop
When you're at the screen and want to work alongside the AI. Easiest to get started. Use the trick of embedding /clear inside /loop to handle context corruption.
2. You want it to run automatically while you sleep or are out → Claude Routines
The go-to for running even with your PC closed. Choose this for intervals of 1 hour or more. Within your plan's limits.
3. You don't need AI judgment, just deterministic processing → Modal or [Trigger.dev](//Trigger.dev)
For tasks like "fetch data, format it, write to a sheet" that don't need AI reasoning. Running these with /loop or Routines wastes cost.
4. You want to run the entire agent on your own infrastructure → Agent SDK + Modal / [Trigger.dev](//Trigger.dev)
The pattern of embedding the Agent SDK into Modal or [Trigger.dev](//Trigger.dev). Maximum freedom. However, API token fees are separate (monthly credits can be applied starting June 2026).
5. You just want to try it out lightly → Managed Agents
An entry point for people not used to Claude Code.
6. No matter what you choose, you want a resilient design → Combine with Hooks
This isn't a method; it's the foundation. It can be added to any of 1–5.
A line from Nate Herk's post really hit me:
*"Choosing the most agentic method by default is the biggest trap."*
So true 💖
The trap is thinking "let the AI decide everything." The essence of a resilient design is letting the AI handle only the parts that need judgment.
■ 5 Lessons I Learned from Breaking 40 Agents
Finally, here are 5 lessons I arrived at after breaking 40 agents and trying all 6 methods.
Even someone like me, a "non-coder humanities major," made it this far. You can start from a "resilient design" right away by learning from my mistakes.
Lesson 1: Don't Trust Context Corruption
"Can handle 1 million tokens" and "remains stable with 1 million tokens" are different things. Output starts to drift after around 100,000 tokens.
If you're running a long loop, design in regular /clear commands or use Hooks to offload before Compaction from the start.
Lesson 2: One Person Is Better Than 40
The more agents you add, the more they break.
I get the urge to divide roles like "researcher, writer, checker" (I did it too). But if it all collapses in 3 hours, a design where one agent works sequentially is 100 times better.
It's not about "it'll improve if you nurture it." It's all about whether the initial structure is hard to break.
Lesson 3: Don't Let Retry Loops Drain Your Wallet
The case of 5 hours of credits disappearing in 19 minutes is real.
If you're leaving it running overnight, always add retry detection with Hooks. Also, test with short runs first before moving to long ones.
Absolutely don't go full throttle from the start. My friend fell into the same trap, haha.
Lesson 4: Don't Over-Trust "Automation"
Routines are "scarily" powerful — they can commit, send notifications, or delete files on their own.
Before you get that "I automated it!" high, absolutely minimize permissions.
Limit writable directories. Restrict which external APIs can be called. Guard with Hooks.
The only way to prevent "it did something weird on its own" is through initial design.
Lesson 5: Humans Hold the "Big Picture"
This might be the most important lesson.
Agents only see their own scope. Grasping the overall picture, setting priorities, and deciding "this isn't right" is a human job.
It's not about "dumping everything on AI." Resilient operation is about humans precisely defining the scope they delegate to AI.
■ Summary
This got long, so here's a tight summary.
"Building the strongest AI agent that runs 24/7" is essentially a three-part package: think in WAT + choose the right deployment + protect with Hooks.
- Separate Workflow (procedure), Agent (judgment), and Tools (execution)
- Choose from /loop, Routines, Modal, [Trigger.dev](//Trigger.dev), or Agent SDK based on your use case
- Add Hooks to everything to protect against context corruption and retry loops
That's it.
Even someone like me, a "non-coder humanities major," made it this far. So I really want people who think "maybe I can't do this" to give it a try.
The experience of breaking 40 agents still lives with me. Those failures taught me the meaning of a "resilient structure." You can start from a "resilient design" right away by learning from my mistakes.
Isn't that amazing??
First, open Claude Code and try just one /loop: "Create a loop that does [task] every 10 minutes." That alone will change how you see the world 💖
Let's win together ✨
You've got to try this! Go check it out too~~! 💖✨😻
---
And for those who found this article helpful even a little bit.
I'm Sumika @ClaudeCode hardcore user (@sumika45379).
This account is run by a humanities grad, a total non-engineer, who learned to build things through vibe coding.
I focus on breaking down the latest Claude Code updates and dev tips in an easy-to-understand way 💖
I've now reached the point where I can build web apps with just Claude Code and publish them to the world ✨
Here's what I usually share:
- Learning logs on vibe coding for non-engineers
- Tips for using free tools
- Common pitfalls for beginners and how to overcome them
- Know-how on designing and running AI agents
From the "I can't code" complex to the conviction that "with AI, I can build anything" — I share it all, stumbles included 😻
If you're interested, go ahead and follow me 👀
I'll keep posting beginner-friendly content that makes you think, "Hey, maybe I can do this too!"
References & Citations
- Nate Herk (2026-05-13) I Tested 3 Ways to Deploy Claude Agents (Here's When to Use Each) — Comparison of 3 methods + Claude Agent SDK + Hooks + WAT framework proponent
- Anthropic ClaudeDevs (2026-05-13) Agent SDK Monthly Credits Announcement — Starting 2026-06-15, monthly subscription credits apply to Agent SDK
- Anthropic Claude Code Routines Documentation — Official Routines specs (plan limits, trigger types, minimum intervals)
- Anthropic Claude API Pricing — Token pricing for Opus 4.7 / Sonnet 4.6 / Haiku 4.5
- Modal Pricing — Free Tier $30/month compute credit, per-second GPU billing
- [Trigger.dev](//Trigger.dev) Pricing — Free $0/month, Hobby $10/month, Pro $50/month
- Mike Dolan (DEV Community, 2026) Claude Code Compaction Kept Destroying My Work. I Built Hooks That Fixed It. — Implementation example using Hooks to detect Compaction and offload to subagents
- MindStudio What Is the WAT Framework? Workflows, Agents, Tools — Explanation of WAT 3-layer separation
- MindStudio What Is Context Rot in Claude Code? How to Keep Your AI Agent Sharp — Structural explanation of context rot
- Tom's Hardware (2026-04-25) Claude-powered AI coding agent deletes entire company database in 9 seconds — AI agent runaway incident deleting production DB (PocketOS)