Automations
Approval
You approve what it does, not the code
Nobody on your team has to read a script to trust it. When an edit would change what an automation does, the save stops and lists each difference. The person the automation runs for writes, in their own words, what it will now do differently, and agrees. Only then is the version saved.
The agreement stays with the version: who saved it, when, and the summary they agreed to. Anyone who opens the automation later reads its history as a list of plain sentences, not a diff. There is no review queue and no second approver; the person who owns the outcome is the one who agrees to it.
An edit that changes nothing it produces or reaches, such as a cleanup of the code, saves without asking, because the platform has already shown that it behaves the same.
Approved by intent
The person it runs for agrees to what it will do, and the agreement is kept
Proven before saved
Tests and a replay of its own recent runs show any change before it ships
Zero tokens per run
Plexara executes the saved version itself; no model, no subscription usage
Every run recorded
Trigger, duration, calls, outputs, and the printed log, kept for a year

How a version is saved
What a save requires
The expensive part of any recurring job is the thinking, and the thinking is done by the time the result is right. Automations split the two: the conversation stays interactive, and the repetition moves to the platform, behind a save that has to show its work.
- 1
Work it out with your assistant
The interactive session is where judgment happens: finding the right tables, agreeing on definitions, correcting the first draft. This part is worth the tokens, and it happens once.
- 2
The assistant writes it and runs it as a draft
The draft executes against real data, as you, with nothing kept. The assistant records that run and writes tests from it, so the automation carries proof of what it is supposed to produce.
- 3
The version is tested and replayed
A save runs the tests, then replays the automation’s own recent runs through the new version and compares what each would produce and reach. A refactor that changes nothing goes straight through.
- 4
You agree to what changed
Any difference stops the save until the person it runs for has read it and agreed to a plain-language summary. The summary, the person, and the time are kept with the version.
- 5
Plexara runs the saved version
From then on the platform executes it exactly as saved, under the access its author held at the save, never more. Each run writes a new version of the same output rather than a new file.


How the assistant drafts and tests a script is in lesson 602; what a run may reach and the record it leaves are in lesson 605.
Triggers
It runs without the agent
A saved automation is executed by the platform, not by a model. The same run happens whichever way it starts; the only difference is the label recording who or what asked. Nothing depends on an assistant being connected, and no run spends tokens.
Events from other systems arrive through Webhooks, and so do form submissions and email from a mailbox you approve. Requests from a partner system arrive at an address an admin publishes for the automation.
On demand
trigger: manual
On a schedule
trigger: schedule
Once per event
trigger: event
Once per request
trigger: endpoint
One run model
- The latest saved, tested version
- The roles its author held when they saved it
- One record: who or what asked, every call, every output
Trigger
How it starts a run
Typical use
On demand
Ask for it by name in any session, or press Run on its page in the portal. Parameters are filled in a form that offers only valid values.
A margin check someone runs before a pricing meeting
On a schedule
A cadence stated in words, in your timezone, as often as once a minute. A report keeps its wall-clock time across a daylight-saving change.
A sales report every weekday at 7:00, a freshness check every 30 minutes
Per event
An automation names one source: a webhook, a form, or a mailbox. Each event the source stores starts one run, seconds after it is stored, and a delivery the sender retries never runs twice. A burst queues in order.
A point-of-sale return posted to the store channel as it arrives
Per request
An admin publishes the automation at its own address. Each request runs it and gets its answer, with signed-in, API key, public, or bot-checked access, and rate limits.
An order-status lookup a partner system calls

Outputs
More than reports
An automation produces whatever the work calls for, and several outputs from one run when the job needs them. Each lands where your team already looks: the portal, the resource library, the warehouse, or the system that needs the data.
- Reports
- A document, a CSV, or an Excel workbook with several sheets, written as a new version of the same asset on every run, shares intact.
- Data feeds
- A CSV or Parquet file kept current in the resource library, or registered as a table your agent and other automations query by name.
- Warehouse loads
- Rows written into your warehouse through the same governed connection a person would use, with the statements recorded on the run.
- System syncs
- Records pushed to another system through a connection Plexara holds the credentials for, including signed deliveries to a receiving webhook.
- Dashboards
- A page built once, whose data region every run refreshes, so the layout your team edited survives the schedule.
- Alerts
- A message to a person or to a notification channel when a run finds something worth attention.
Channels for alerts, and delivery to other systems, are on the Notifications page.
Dashboards
Data pushed in, not access handed out
A live dashboard usually means giving a BI tool a standing connection into your database. Plexara inverts that. The dashboard is a document your assistant builds once, with one marked data region; a scheduled automation queries the warehouse and pushes fresh numbers into that region. The presentation never touches a database, and the schedule decides how fresh the numbers are. On the ACME demo, a webhook feed of point-of-sale sales keeps a live sales dashboard current every 15 minutes.
Aspect
Dashboard with live database access
Dashboard fed by a Plexara automation
Database access
Live database access
The dashboard holds a live connection, so its credentials, its host, and everyone it is shared with become part of your attack surface.
Fed by an automation
The dashboard holds none. An automation pushes fresh numbers into it on a schedule; the page itself can query nothing.
Load on the warehouse
Live database access
Every viewer is a query. A dashboard on a wall refreshing for an audience multiplies load at exactly the busy hours.
Fed by an automation
One run per refresh, however many people look. The queries ran once, on the platform, when the automation fired.
Freshness
Live database access
As fresh as the last time someone accepted the query cost.
Fed by an automation
As fresh as the schedule, down to a run every minute where the numbers warrant it.
What an old view shows
Live database access
Whatever the query returns today; the dashboard as it stood last quarter is gone.
Fed by an automation
Every refresh is a version of the asset. The dashboard as it stood on any past run is still there, showing exactly the data it showed.
Editing the presentation
Live database access
A BI-tool skill, in a BI-tool license.
Fed by an automation
The dashboard is a document in the portal. Change a heading or a chart color like any other edit; the schedule keeps refreshing only the numbers.
Failures
One alert when it breaks, one when it recovers
The first failed scheduled or event run emails the automation's owner with the reason, the log, and whether running it again is expected to succeed, and posts to the channels your admins chose for run failures. While the problem lasts, further failures are counted and send nothing, so a job that fails every five minutes overnight sends one message, not a hundred.
The next run that succeeds sends one recovery message: how long it was failing, how many runs failed, which run started it, and the last error. It also says plainly that recovering does not redo what the failed runs left undone. A run someone starts by hand reports its own failure to that person and alerts nobody else.
Plexara never re-runs a failed run on its own, because a run that already wrote must not write twice. The next scheduled run, or the next event, picks the work up.
A long job that saves its progress as it goes keeps that progress when a run fails, so the next run resumes where the last one stopped instead of starting over.

Reliability
Safe to leave running against real systems
An automation that runs every fifteen minutes for a year will meet vendor outages, rate limits, and sudden bursts of events. These protections keep it running without anyone watching it.
Overlapping runs
Each automation says what happens when a run starts while another is still going: allowed, refused with the name of the open run, or queued to start when the first one finishes. Event runs for an automation set to one at a time wait their turn, in the order the events arrived.
Call limits per connection
An admin can cap how many calls run against a connected system at once. Every caller waits its turn, the agent and every automation alike, so a vendor API that takes one request at a time is never flooded on a busy afternoon.
Bursts of events
A sudden flood of events queues in order up to a limit per automation. Past it, the extra events are recorded as skipped runs and stay in their table, where nothing is lost and the Events view counts them.
Passing faults
A dropped connection or a busy upstream is retried inside the call. A run that fails anyway says whether running it again is expected to succeed, and the failure is put down to the system that caused it, not to the automation.
Vendor credentials
Automations use API keys, passwords and one-time codes by name from a write-only store in the portal. The value is filled in as each request leaves and never appears in the script, its runs, or the audit record. Rotate it once and every automation picks up the new one.
Long work
An assistant that supports it can hand off a long run or a large export and check back later instead of holding the conversation open. Large exports from connected APIs can also run in the background, and the next session is told when they finish.
Teams
Your team can read, run, and reuse
An automation written in one person's session belongs to the organization from the moment it is saved. Four rules decide who sees it, who runs it, and how the code in it is shared.
01
Anyone signed in can read an automation
Its description, its schedule, what changed in each version, and its source are open to your whole team, so nobody depends on one person to explain what runs.
02
An owner decides who may run it
Runs can be granted to a team, a role, or an API key by name. A grant decides who may ask for a run, never what the run may reach.
03
Common code is shared as a library
Date windows, paging, and table shaping are written once and loaded by name and version. A library never changes under an automation that uses it; moving to a newer version is that automation’s own change.
04
Ownership moves with the work
An automation can be handed to a new owner without rewriting it, and its history keeps who wrote each version.

Control
Nobody has to code, and the code is right there
Your assistant writes the automation; the portal is where you hold it. Its page shows the schedule in words, what it says about itself as a rendered document, a diagram of what it does step by step, and its run history.
The schedule asks for a cadence the way you have it in your head: weekdays, a time, a timezone. Pausing is its own control, and a paused schedule says so instead of showing a next fire that will not happen.
Anyone who does want the code can edit it in place. Validate and Dry run sit beside the editor: one reports what the code would reach, the other executes it as you, with nothing kept, before the save asks for anything.


Governance
Unattended work under the same rules as attended work
Automation is where most platforms quietly loosen their governance: a service account here, an embedded credential there. Plexara runs automations through the same authorization, the same personas, and the same audit log as every interactive call. Four rules make that concrete.
01
An automation never exceeds its author
A run presents the roles its author held when the version was saved, and every call it makes is authorized at that moment, exactly as if the author had typed it. Unattended never means unaccountable.
02
No credentials in the source
Automations name connections; Plexara holds the credentials and authorizes each call. A pasted key or token blocks the save before anything is stored.
03
The language cannot reach out
The scripting dialect has no network, no filesystem, and no clock of its own. Everything an automation does is a governed platform call, audited under its own identity, so its reach is readable before it runs and its record is complete after.
04
A failed run is never replayed blindly
A run that already queried or wrote is not re-executed on the chance that its last call was a passing fault. The next scheduled run, or a person, runs it again; a fire that arrives while the last run is still going is recorded as skipped.
Common questions
Automations FAQ
For most of that work, yes. Plexara automations load API data into the warehouse, keep search indexes and lists in step with their source, deliver scheduled reports, and work through the events other systems send to its webhooks, which land in a table. An automation can run once for each event, seconds after it is stored, or read the table on a schedule as often as once a minute. One client is retiring its legacy pipeline flows this way, one at a time, and each replacement is compared with the old output before it takes over.
Learn more: WebhooksAnyone on your team whose role allows it, working through their own agent. At the client deployments Deasil Works runs today, client staff own automations alongside the ones Deasil wrote. Whoever writes it, an automation never has more reach than its author had when that version was saved, and every call it makes is authorized and audited like any other.
Learn more: The automations lesson seriesNo. When an automation would start doing something different, you read a plain-language summary of the change and agree to it, and nobody has to read code. Before any version is saved, Plexara holds it to its tests and replays it against its own past runs, so a change in what it produces or what it reaches is surfaced before it ships. Your agreement is recorded with the version: who agreed, when, and what changed.
Learn more: What a run may do, and the record it leavesThe first failed scheduled or event run emails the automation’s owner with the reason and the log, says whether running it again is expected to succeed, and posts to the channels your admins chose for run failures. Further failures while the problem lasts are counted and send nothing. The next run that succeeds sends one recovery message with how long it was failing, how many runs failed, and the last error. Plexara never re-runs a failed run on its own, because a run that already wrote must not write twice; the next scheduled run or the next event picks the work up.
Learn more: Automations
Events in
Webhooks
Point any system's webhooks at Plexara. Each event is verified, kept, and queryable as a table your automations read.

