AutronAI

AI AGENT AUTOMATION

Put AI work on a schedule

Turn a task into Automation that can run once or on a recurring schedule. AutronAI connects scheduled work to an eligible Chatbot and integration, keeps the instruction and timezone explicit, and gives you a place to manage future execution and inspect every run.

Scheduled work, inspectable runs
AutronAIRun
InstructionScheduleTimezoneChatbotResult
01Define02Schedule03Inspect

Beyond a new message

AI work does not have to begin with a new message

Some work belongs at a future time or on a repeating cadence: every hour, every day, on weekdays, or according to another recurring schedule. Automation makes that timing explicit without requiring a new interactive message each time.

Instruction

The work to perform when the scheduled moment arrives.

Schedule

A one-time moment or recurring cron cadence, paired with a timezone.

Operation

The controls and run records that keep future execution visible.

System architecture

Automation sits around the configured AI system

Automation schedules configured AI work rather than creating another unrelated Agent or resource model. It carries an instruction, schedule, and timezone into an eligible Chatbot; the Chatbot brings its Agents and Memory; each scheduled execution becomes a Run with a result and, where applicable, delivery information.

Automation

Instruction · Schedule · Timezone

Chatbot

The configured composition of Agents and Memory.

Run

One scheduled execution of the persistent definition.

Result / Delivery

The output and the separate delivery outcome exposed for that Run.

Eligibility

Start with an eligible Chatbot

The current workspace only offers a Chatbot for Automation when access_scope === "private" and automation_enabled is true. The Automation also retains its integration and platform context so the scheduled work is routed through the configuration it belongs to.

Define the work

Write the task as a clear instruction

The schedule answers when. The instruction answers what.

Write an outcome-oriented instruction that will still make sense when it runs later without a fresh conversational prompt. Include the necessary scope and expected result, but keep internal orchestration details out of the instruction.

One-time schedule

Run once when the task has a specific moment

Choose the once schedule type for work tied to one known future moment. The interface captures that moment and sends it as run_at, while the schedule model also requires a timezone. A one-time schedule is not a recurring cadence.

Recurring schedule

Repeat work with a cron schedule

Choose cron for a repeating cadence. The management UI provides current presets for common schedules and also accepts a custom five-field cron expression; the presets are conveniences, not the only valid expressions.

Hourly

0 * * * *

Run at the start of each hour.

Daily

0 8 * * *

Run each day at the configured schedule's 08:00.

Weekdays

0 8 * * 1-5

Run at 08:00 from Monday through Friday.

Custom

Five fields

Enter another supported minute, hour, day-of-month, month, and day-of-week cadence.

Schedule context

Timezone is part of the schedule

Both once and cron schedules include a timezone. Keeping it beside the schedule makes the intended local context explicit instead of leaving readers to infer it from a timestamp or expression. The page does not promise timezone behavior beyond the current schedule contract.

Operational visibility

Know when the Automation is expected to run again

The Automations table exposes next_run_at when another execution is expected. It gives you an operational checkpoint for the current definition; when no next run is available, the workspace shows no date rather than inventing one.

Future behavior

Edit future behavior without recreating the Automation

The current editor can update the name, instruction, schedule type, cron expression or once datetime, and timezone. Editing changes the managed definition for future behavior; it does not rewrite historical Runs.

Lifecycle controls

Pause recurring work without deleting it

Keep the definition while deciding whether it should continue, or remove it when it should not schedule again.

Pause

Stop creating future scheduled Runs while retaining the Automation.

Resume

Allow scheduling to continue again from the retained definition.

Delete

Prevent future scheduled Runs by deleting the Automation.

Definitions and executions

Keep Automations and Runs separate

An Automation is the persistent definition: what should happen, when, and through which configured system. A Run is one scheduled execution of that definition. The current workspace reflects this distinction with separate Automations and Runs tabs.

Automation

The name, instruction, schedule, timezone, status, configuration references, and next expected run.

Run

One execution record with schedule time, execution state, delivery state, latency, error information, and an inspectable result.

Run lifecycle

Follow the lifecycle of each run

A Run can expose any of the current statuses below. They describe possible lifecycle states; they do not imply that every Run passes through every state in one identical sequence.

pending

Recorded and waiting for dispatch work.

dispatching

Being sent toward execution.

accepted

Accepted by the execution path.

completed

Execution completed.

failed

Execution ended with a failure.

timed_out

Execution exceeded its allowed time.

cancelled

The Run was cancelled.

skipped

The scheduled execution was skipped.

Operational signals

Inspect more than whether the task worked

The Runs table brings several signals into one view: scheduled time, Automation, Chatbot, platform, run status, delivery status, response time, and error code. Execution and delivery are separate concerns, so one label does not have to hide the other.

Individual result

Open the result of an individual run

Open a Run to inspect its status, delivery, latency, error, and output_message. This is a focused result view—not a promise of full tracing, hidden reasoning, or a step-by-step internal transcript.

Delivery

Delivery has its own status

Delivery can be pending, delivered, or failed. Keeping delivery status separate from execution status helps distinguish whether the scheduled AI work ran from what happened when its output moved through the configured integration.

Run history

Filter run history when the list grows

The current Runs view can filter by Chatbot, platform, status, and a bounded time range. Available ranges are 1h, 3h, 6h, 12h, 1d, 2d, 7d, 14d, and 30d. This is operational history, not an unrestricted analytics claim.

Composed capabilities

Scheduled work can use the capabilities already composed around the Chatbot

The Chatbot remains the composition root. Memory attaches to the Chatbot; structured data, documents, MCP tools, and custom behavior are configured through their relevant Agents. Automation schedules work around that existing composition.

Memory

Reusable context attached at the Chatbot level.

Structured Data Agent

Works with its selected structured sources and approved scope.

Document Agent

Retrieves from the document sources configured for that Agent.

Tool / Custom Agent

Uses selected MCP tools or focused Skill-driven behavior.

Clear boundaries

Automation and tools solve different problems

Tool

What external action can the Agent perform?

Skill

What reusable procedure should it follow?

Automation

When should the configured work execute?

Run

What happened during one scheduled execution?

Choose the cadence

Use one-time and recurring Automation differently

once

Use one known future moment for a task that should execute a single time.

cron

Use a repeating cadence for an instruction that remains meaningful each time it runs.

Current scope

Automation is scheduled, not event-triggered

The current product supports once and cron schedules. It does not present arbitrary webhook, incoming email, database-change, price-threshold, condition-monitoring, or event-bus events as Automation triggers.

From configuration to evidence

A practical Automation workflow

Configure

Build the Chatbot and the capabilities its scheduled task needs.

Enable

Use an eligible private Chatbot with Automation enabled.

Define

Give the Automation a clear name and outcome-oriented instruction.

Schedule

Choose once or cron and make the timezone explicit.

Operate

Edit, pause, resume, or delete as future needs change.

Inspect

Review Runs, delivery, latency, output, and errors.

Durable instructions

Useful Automation starts with repeatable intent

Scheduled tasks work best when their instruction remains meaningful later without a new interactive prompt. That can include a recurring summary, periodic review, scheduled preparation, repeated check, or future follow-up—across any use case where the timing and desired outcome can be stated clearly.

Four questions

Keep each Automation understandable

What should happen?

State the outcome in the instruction.

When should it happen?

Choose once or cron and specify the timezone.

Which AI system performs it?

Select the eligible Chatbot and integration context.

How can I inspect it?

Use the Runs view and open the individual result.

Control

Scheduled execution should remain controllable

Automation should remain visible and manageable after it is created.

Use next run as a forward-looking signal. Edit the future definition, pause or resume scheduling, delete work that should no longer continue, and use run history to inspect what happened.

FAQ

Questions, answered

Frequently asked questions

What is AI agent automation in AutronAI?

Automation is a managed schedule around an eligible Chatbot. It combines a durable instruction with a one-time or cron schedule and timezone, then records each scheduled execution as a separate Run.

Which Chatbots can be used for Automation?

The current workspace offers Chatbots whose access_scope is private and whose automation_enabled setting is true. The Automation also retains the relevant integration and platform context used by the scheduled work.

Does AutronAI support event-triggered Automation?

The current product supports once and five-field cron schedules. It does not present arbitrary webhook, email, database-change, price-threshold, or event-bus triggers as Automation inputs.

What can I inspect after an Automation runs?

The Runs workspace exposes status, scheduled time, related Automation and Chatbot, platform, delivery status, response time, error code, and an individual result with output_message where available.

What is the difference between an Automation and a Run?

An Automation is the persistent definition of what should happen and when. A Run is one execution record created from that definition. Editing future schedule behavior does not rewrite historical Runs.

Build with AutronAI

Let useful AI work continue on schedule

Define the task once, choose when it should run, and keep execution visible through controllable Automations and inspectable run history.