How Facio's Built-in Cron Scheduler Enables Fully Autonomous Agent Workflows
Most AI agent runtimes are interactive by design. You send a message, the agent processes it, you get a response. That model works for ad-hoc tasks — but it breaks down as soon as you need the agent to run on a schedule. Monitoring a system every hour. Generating a daily summary. Scanning for regulatory changes and surfacing only what matters.
The typical solution is to wire the agent to an external scheduler: a systemd timer, a Kubernetes CronJob, a cloud function. This works, but it adds operational complexity, fragments the audit trail, and creates a dependency chain that fails silently when any link breaks.
Facio takes a different approach: the cron scheduler is built into the runtime itself. It shares the same agent loop, the same audit trail, and the same human-in-the-loop (HITL) checkpoints. Here is why that architecture matters and how to use it.
The Problem With External Scheduling
When you schedule an AI agent via an external cron mechanism, you introduce a series of failure points that are hard to detect and harder to debug:
Cold starts without context. Each cron invocation launches a fresh agent session. The agent has no memory of what it did last time, what it already reported, or what changed between runs. This forces you to either rebuild context from scratch on every execution or build a state-persistence layer on top of the scheduler.
Silent failures. A systemd timer that fires when the agent process is stuck produces no output and no notification. The job simply fails, and you find out when you manually check — potentially days later.
Fragmented audit trails. The scheduler logs "job started at 09:00" and "job exited with code 0." The agent logs its actual reasoning and tool calls separately. When something goes wrong, you have to correlate two independent log systems to understand what happened — and neither system knows what the other was doing.
No HITL integration. An external scheduler triggers the agent, but it has no mechanism to pause execution and wait for human approval. If the agent encounters a decision that requires review, the scheduler has already moved on.
Claude Code's Loop feature, released in early 2026, addresses some of these issues with a 72-hour scheduling window — but it requires the agent to stay connected the entire time. For production workflows that run indefinitely across days, weeks, or months, a persistent scheduler is essential.
How Facio's Cron Architecture Works
Facio's scheduler is not a wrapper around the agent. It is part of the same runtime, sharing the same execution pipeline. Here is the architecture:
The Agent Loop and Scheduler Are One System
Every message that enters Facio — whether from a user typing in a chat channel or from a cron job firing — flows through the same agent loop. The loop loads the session, builds context from memory and skills, and executes the tool-calling cycle. The scheduler does not bypass the agent; it speaks through the same pipeline.
This design means cron-triggered tasks benefit from every capability that a user-triggered task gets: access to all tools, memory of previous runs, skill-defined behaviors, and HITL approval checkpoints.
Three Schedule Types
Facio supports three scheduling modes, each suited to different use cases:
at— One-time execution at a specific ISO timestamp. Use this for reminders, deadline-triggered actions, or deferred tasks.every_seconds— Recurring interval in seconds. Use this for monitoring loops, periodic health checks, or any task that needs to run on a short cadence.cron_expr— Standard five-field cron expressions with optional timezone support. Use this for daily summaries, weekly reports, or any task tied to a calendar schedule.
Two Job Kinds
Not every scheduled task needs the full reasoning power of an LLM. Facio distinguishes between two job types:
Agent Turn jobs inject a message into the agent loop. The LLM processes the task, uses tools as needed, and delivers results. This is for tasks that require reasoning: "summarize today's regulatory changes and flag anything affecting client portfolios," or "check if the deployment succeeded and report any anomalies."
Script Exec jobs run a shell command or script and deliver the output. This is for deterministic tasks that do not need AI reasoning: "run df -h and report disk usage," or "execute the nightly backup and confirm completion." These jobs are cost-free from an LLM perspective — no tokens consumed.
HITL at Every Scheduling Layer
Every cron job can be configured with require_approval: true. When set, the agent pauses before executing the scheduled task and requests human sign-off via Placet.io. The approval request lands in the reviewer's inbox — wherever they work, whether Telegram, Discord, or the web interface — and the job waits until the human responds.
This is the feature that makes scheduled automation viable in regulated environments. A daily client-report generation job can run automatically, but the agent will not send anything to a client without explicit approval.
Production Use Cases
Compliance Monitoring That Never Sleeps
A Facio agent configured with a cron job checks regulatory feeds every six hours. When it detects a change in a jurisdiction where clients have filing obligations, it drafts an impact summary and queues it for human review. The Steuerberater or tax advisor sees the alert, reviews the analysis, approves it, and only then does the client receive the notification.
The entire process — from scheduled check to client communication — is captured in a single, timestamped audit trail.
Daily Standup Reports
A cron_expr job fires every weekday at 09:00. The agent pulls recent activity from project management tools, checks deployment status, and compiles a standup summary. The team lead reviews it in their Placet.io inbox and forwards it to the team channel. No manual status gathering required.
Heartbeat-Driven Task Processing
Facio supports a HEARTBEAT.md file checked on a configurable interval. The agent reads its heartbeat tasks, executes any that are due, and updates the file. This is ideal for maintenance workflows that need to run continuously without rigid scheduling — think "check for outdated dependencies every 4 hours" or "verify SSL certificate expiry daily."
Getting Started
Adding a recurring task in Facio is a single tool call:
{
"action": "add",
"name": "daily-compliance-check",
"message": "Check regulatory feeds for changes affecting our client portfolio. Flag anything material and draft an impact summary.",
"cron_expr": "0 9 * * 1-5",
"tz": "Europe/Berlin",
"require_approval": false,
"kind": "agent_turn"
}
This creates a job that runs every weekday at 09:00 Berlin time, checks regulatory feeds via the agent's web tools, and delivers results to the configured channel. No external scheduler. No wrapper script. No infrastructure to maintain.
Why Built-in Scheduling Is a Hard Requirement
Running AI agents in production means accepting that many workflows are not request-response cycles. They are ongoing processes that need to wake up, check conditions, reason about changes, and act — or wait for approval — on a defined cadence.
External schedulers create complexity, fragmentation, and silent failure modes that undermine the reliability of autonomous agent operations. A built-in scheduler, sharing the same loop and audit trail, eliminates those failure modes and makes recurring agent workflows as reliable as interactive ones.
Facio's architecture reflects a design principle that matters in production: the scheduler is not an add-on. It is part of the runtime, because autonomous operation is not a feature — it is the default state of a deployed agent.
Facio is available as a single Docker container. Get started in 5 minutes →