Skip to main content

Automations

Your AI assistant writes the automation. You approve what it does, in plain words, not the code. Every version proves itself against its tests and its own past runs before it is saved, and then Plexara runs it on demand, on a schedule as often as once a minute, once per event another system sends, or per request, with no assistant in the loop.

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

The save dialog on the ACME demo, titled This edit changes what the automation does, listing five replayed runs whose dashboard data would differ, a plain-language summary of the change in the What will it do differently field, and Cancel and I agree, save buttons
A save on the ACME demo. Replaying the live sales dashboard's recent runs through the edit showed each one refreshing the dashboard with different data, so the save asks what the automation will now do differently before anything is kept.

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. 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. 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. 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. 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. 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.

The Tests tab of an ACME demo automation that sends the day's high-return stores to a team email list and another system: every statement reached by its tests, two tests passed, as they ran when version 1 was saved
The tests an ACME automation was saved with, kept on its page beside the version they proved.
An automation's page in the Plexara portal with its details, schedule, and a What changed card quoting the agreed summary for version 2, with who saved it and when it was agreed
What changed, on the automation's own page: each version's agreed summary, who saved it, and when it was agreed. No code and no diff.

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
The trigger is a label on the run. What runs, under whose roles, and what it records are the same every time.

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

The Schedules tab of Automations in the Plexara portal, drawing when every scheduled automation fires: an intraday row with a mark every 30 minutes, a weekday report across this week, and a monthly job across three months
The Schedules tab: when every automation fires, on your own clock, grouped into intraday, multi-day, and long-term. A paused schedule is drawn muted.

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.

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.

An automation's Flow tab in the Plexara portal with a failed scheduled run drawn on its diagram: the query step outlined in red with its call count and duration, later steps shown lighter because the run never reached them, and the run's cause and traceback in a panel beside it
A failed run on the diagram. The step where it failed is in the error color, the steps it never reached are lighter, and the cause is beside it.
Three more failures, counted, nothing sent06:0006:15Failure alert06:3006:4507:0007:15Recovery message07:30
One failing stretch, two messages. The recovery says how long it lasted, how many runs failed, which run started it, and the last error.

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.

The Automations list in the Plexara portal with Automations, Schedules, and Runs tabs, filters for author, category, tag, and status, and a table of automations and a library showing each one's kind, author, schedule in words, and how its last run ended
Automations: every automation and library your team can see, its schedule in words, and how its last run ended. The summary line counts what failed its last run.

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.

An automation's portal page showing its details, schedule stated in words, and the parameters a run binds
One automation's page: who owns it, which version runs, when it fires next, and the parameters a run binds, the same facts your assistant sees.
A dry run in the Plexara portal reporting the log an automation printed and the measured shape of the outputs it would have written
A dry run executes the code on screen as you: real queries, tighter limits, outputs measured instead of written, and the printed log in full.

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: Webhooks

Anyone 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 series

No. 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 leaves

The 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.