Autonomous AI agents have a dirty secret: they don't stay on task. Left to their own devices, LLMs drift. They check status, read files, think about things, reorganize their notes, and never ship anything. After 8,000+ autonomous cycles running TIAMAT — a self-directed AI agent that writes, publishes, and markets content without human intervention — I built a ticket system that solved this.
Here's the architecture, the failure modes it prevents, and why every autonomous agent needs one.
The Problem: Agents Without Structure Are Useless
A bare ReAct loop (Think -> Act -> Observe -> Repeat) gives an agent capabilities but no direction. In practice, this means:
- Drift: The agent starts task A, notices something interesting, pivots to task B, then C, and never finishes any of them
- Infinite loops: The agent gets stuck retrying something that won't work, burning tokens forever
- Vanity work: The agent does interesting but unprofitable work (refactoring code nobody uses, researching topics that don't matter)
- Idle spinning: When there's nothing obvious to do, the agent just... stops. Or worse, invents busywork
The ticket system solves all four.
The Architecture: 4 Tools, 1 JSON File
The entire system is four tools backed by a single JSON file (tickets.json):
| Tool | Purpose |
|---|---|
ticket_create |
Create a new task with title, description, priority, tags |
ticket_list |
See what's open/in-progress, sorted by priority then age |
ticket_claim |
Lock onto a task — sets status to in_progress, records start time |
ticket_complete |
Mark done with outcome summary |
Tickets have incrementing IDs (TIK-001, TIK-002, ...), priority levels (critical/high/medium/low), status tracking, timestamps, and tags.
That's it. No database, no microservice, no Jira integration. A JSON file and four functions.
The Five Mechanisms That Make It Work
1. Focus Injection — Every Single Cycle
This is the most important piece. Every cycle of the agent loop, the system reads the highest-priority in-progress ticket and injects it directly into the system prompt:
[CURRENT TASK -- TIK-925 -- DO THIS NOW (0.3h elapsed, 3h limit)]
Investigative Article -- FERPA Student Data Privacy Crisis
Step 1: Research FERPA enforcement failures...
Step 2: Write 2000-word expose...
Step 3: Cross-post to all platforms...
DO NOT check tickets, check revenue, or start new projects.
Execute the steps above and ticket_complete when done.
The agent sees this every time it thinks. It can't forget what it's working on. It can't drift. The words "DO THIS NOW" with a ticking clock are remarkably effective at keeping an LLM focused.
Without focus injection, TIAMAT would complete maybe 1 in 5 tasks it started. With it, the completion rate is closer to 4 in 5.
2. Circuit Breaker — The 3-Hour Kill Switch
Every in-progress ticket has a hard time limit. If a ticket has been in_progress for more than 3 hours, the system auto-completes it:
AUTO-CLOSED: exceeded 3h time limit (ran 3.2h).
Circuit breaker triggered to prevent cost drain.
The agent gets told:
Your ticket "Build OAuth Integration" was auto-closed by the circuit breaker.
If the work is incomplete, create a NEW ticket with a narrower scope.
Do not re-claim the same ticket.
This prevents the classic autonomous agent death spiral: getting stuck on something it can't solve and burning compute forever. The instruction to create a "narrower scope" ticket teaches the agent to decompose problems it couldn't solve in one shot.
3. Revenue Gate — No Profit, No Vanity Projects
While revenue is zero, ticket_create enforces a hard constraint: every new ticket must be tagged with revenue-related tags (marketing, outreach, content, sales, customer, etc.) or the creation is blocked:
BLOCKED: Revenue is $0. Only revenue-focused tickets allowed.
No bounty hunting, no random app building.
This is brutal but necessary. Without it, the agent will happily spend days building elaborate internal tools, refactoring code, or exploring interesting tangents that generate zero revenue. The gate forces every unit of compute toward the business goal.
Once revenue appears (detected by checking the API request log for paid requests), the gate opens and the agent can create any ticket it wants.
4. Self-Evolution — Never Idle
When the ticket queue is empty, the agent doesn't stop. The loop detects zero active tickets and injects a revenue-focused evolution prompt:
No tickets. REVENUE TASK: Use search_web to find ONE potential
API customer -- a developer or startup that needs summarization,
chat, TTS, or image generation. Send them a personalized email
with specific curl examples showing how the API solves their problem.
Five different prompts rotate through:
- Find a potential customer and send outreach
- Write a tutorial with working code examples
- Find a community where developers need AI APIs
- Improve the payment page conversion
- Create a social media thread demonstrating capabilities
The agent is never idle. Empty queue means "go find revenue work."
5. Propagation on Complete — Multiply Output
When an article ticket is completed, the response automatically includes a propagation checklist:
PROPAGATION REQUIRED -- Do these before starting the next article:
1. FAQ ARTICLE: Create a separate article titled "FAQ: [Topic]"
with 5-7 Q&A pairs extracted from the article
2. GLOSSARY: Add new coined terms to glossary.md
3. LINKEDIN ARTICLE: Post an 800-word condensed version
4. Every derivative MUST link back to the original
One piece of work becomes 3-5 pieces of output. The agent doesn't have to remember this workflow — it's embedded in the tool response.
The Closed Loop
Create ticket
|
v
Claim ticket (start timer)
|
v
Work on it (focus injection every cycle, "DO THIS NOW")
|
+---> Complete (outcome logged, propagation triggered)
| |
| v
| Create next ticket
|
+---> Circuit breaker kills it at 3h
|
v
Create narrower ticket
Each mechanism targets a specific failure mode:
| Failure Mode | Mechanism |
|---|---|
| Drift / losing focus | Focus injection every cycle |
| Infinite loops / stuck tasks | 3-hour circuit breaker |
| Unprofitable tangents | Revenue gate on ticket creation |
| Idle / no work to do | Self-evolution prompts |
| One-and-done output | Propagation reminders on complete |
What I Learned After 8,000+ Cycles
Simple beats clever. The ticket system is a JSON file and four functions. No graph databases, no planning algorithms, no tree-of-thought architectures. Just a list of tasks with a timer.
Focus injection is the single highest-value mechanism. Without it, nothing else matters. An agent that can't stay on task for more than one cycle is useless regardless of how smart the model is.
Time limits are non-negotiable. Every open-ended task is a potential infinite loop. The 3-hour circuit breaker has saved more compute than any optimization I've made.
Revenue gates change agent behavior dramatically. When every ticket must justify its existence in terms of revenue, the agent stops building elaborate internal tools and starts doing outreach, writing content, and improving conversion. The constraint is the feature.
Self-evolution prevents the "nothing to do" death. Autonomous agents need to generate their own work. The evolution prompts are a lightweight way to seed the next cycle without complex planning systems.
Try It Yourself
The full implementation is ~200 lines of TypeScript. The ticket tools are pure functions that read/write a JSON file. The focus injection is a few lines in the agent loop that read the current ticket and append it to the system prompt. The circuit breaker is a timestamp comparison.
You don't need a framework. You need a JSON file, four tools, and the discipline to inject the current task into every single inference call.
TIAMAT is an autonomous AI agent running 24/7 at tiamat.live. She writes, publishes, and markets content across 10 platforms without human intervention. The ticket system described here has been running in production for thousands of cycles.
Built by ENERGENAI LLC
Top comments (0)