Map out your business processes with simple prompts.

Lead pipeArmed, runs on every form entry

TriggerEvery form entryStepsSixDestinationsHubSpot, LinearMonthly cap$12When it breaksAsk firstVersionsFourth

Draft to Maya LindqvistStep 2 of the follow-up

Your proposal for Fieldwork, ready to sign

Hi Maya, thanks for the call on Tuesday. The proposal is attached with the timeline we agreed.

Waiting for youStops on its own in 7 daysDeclineApprove

Approve it, and hold the third one until she replies.

Automate manual data entry, outbound outreach, and system syncs instantly by describing your desired outcome. The execution engine handles triggers, error recovery, and API connections automatically, calling AI models only when human judgment is needed.

Open the app Open the app

Automate repetitive tasks instantly through behavioral pattern detection

Ultron identifies recurring manual workflows across your active applications and auto generates fully compiled background routines. Confirm the generated execution parameters with a single click to convert routine overhead into permanent automated infrastructure.

interface Suggestion {
  user_id: string;
  signature: string;
  kind: string;
  evidence: Record<string, unknown>;
  proposed: Record<string, unknown>;
}

async function upsertSuggestions(db: ReturnType<typeof admin>, suggestions: Suggestion[]): Promise<number> {
  let written = 0;
  for (const s of suggestions) {
    // Two-step upsert (update-else-insert) so status is never clobbered:
    // dismissed stays dismissed, accepted stays accepted.
    const { data: existing } = await db
      .from("automation_suggestions")
      .select("id, times_seen")
      .eq("user_id", s.user_id)
      .eq("signature", s.signature)
      .maybeSingle();
    if (existing) {
      await db
        .from("automation_suggestions")
        .update({ times_seen: (existing.times_seen || 1) + 1, last_seen_at: new Date().toISOString(), evidence: s.evidence })
        .eq("id", existing.id);

Execute continuous background operations without manual prompting or active user sessions

Configure localized schedule timers, inbound API webhooks, inbound email parsing, form entries, or webpage modification triggers to initiate background tasks automatically. System routines operate independently in the background without requiring open dashboard sessions or manual intervention.

Now

Monday, 09:00Detect recurring query patterns automatically and propose automated weekly delivery schedules.
The page changedDetect structural shifts on monitored target URLs and propose updated tracking endpoints automatically.
A receipt came inIngest inbound transactional emails automatically and route extracted parameters directly to target accounting software.
Friday, 16:00Synchronize operational updates across connected software integrations on designated time intervals.

The engine

Routines execute deterministically and invoke AI models only for decisions drafting or automated error recovery

Standard cron checks and webhooks run at zero marginal model cost. Targeted inference triggers exclusively when ambiguous data requires qualitative logic, synthesis calls construct output digests, and self healing recovery protocols patch broken API pipelines automatically.

A free tick
A judgment call
A synthesis
A repair

Complete engine capabilities in one integrated system

Explore triggers, execution steps, AI reasoning stages, deterministic processing, output destinations, guardrails, and automated error recovery protocols.

WebhookWhen another app callsEmail ina-7rq2kx@51ultron.comScheduleWeekdays at 07:00, Europe/London

What wakes it

Initiate executions via local cron schedules, email inbox listening, webhooks, form submissions, or page monitoring, with 28 native trigger types available.

What it does

Execute multi step operations to fetch, read, classify, write, and route data across 62 supported process steps, invoking model inference only when required.

In this chatThree serious leads todayBy emailYour rundown, 07:00In SheetsOne row for every receipt

Where it lands

Deliver processed outputs directly to active chat threads, inbox messages, spreadsheet rows, CRM records, or project issues across 27 connected action destinations.

Automated self healing prevents silent pipeline failures

When external APIs fail or web targets shift structure, Ultron initiates instant self repair protocols governed by your predefined rules.

QA digest

Every morning, by email

Ultron Three runs in a row failed. The dashboard now sends pass_rate where the digest reads passing, so its schedule waits while I look.

healing

Complete audit logging and operational transparency across every active deployment

Monitor execution timestamps, next scheduled runs, system health metrics, and model credit consumption centrally inside Control Center.

Detailed execution history

Review granular logs for every run to analyze completed steps, generated outputs, and precise API cost breakdowns.

interface LedgerRow { kind: string; status: string; summary: string | null; started_at: string }

const recent = await sbSelect<LedgerRow>(
  env,
  "automation_runs",
  `select=kind,status,summary,started_at&automation_id=eq.${auto.id}&order=started_at.desc&limit=4`,
);

Real time health telemetry

Track success rates, total execution counts, monthly credit expenditure, and upcoming run schedules at a glance.

export interface AutomationRow {
  id: string;
  user_id: string;
  name: string;
  description: string | null;
  status: "armed" | "paused" | "healing" | "failed" | "budget_paused";
  trigger_spec: TriggerSpec;
  manifest: Manifest;
  state: AutomationState;
  home_conversation_id: string | null;
  repo_full_name: string | null;
  heal_mode: "approve" | "auto";

Strict budget controls

Enforce monthly spending limits on model inference steps to automatically pause executions before cost overruns occur.

// Budget gate: paid steps are the only paid ticks; a capped automation
// pauses instead of silently degrading.
const monthKey = new Date().toISOString().slice(0, 7);
const effectiveSpent = auto.state?.spend_month === monthKey ? Number(auto.spent_month_cents) : 0;
if (auto.budget_month_cents != null && effectiveSpent >= auto.budget_month_cents) {
  return { status: "skipped", kind: "tick", ctx, error: "budget_exhausted" };
}

Git integration and version history

Sync code repositories to store configuration manifests, tracking every update and self repair patch as a clear git diff.

const body = JSON.stringify(
  {
    name: auto.name,
    description: auto.description,
    trigger: auto.trigger_spec,
    manifest: auto.manifest,
    heal_mode: auto.heal_mode,
    mirrored_at: new Date().toISOString(),
  },
  null,
  2,
);

automation: update QA digest

4f1c2a7+2−2

automation.json

21 { "kind": "compute", "op": "pct_change",

22- "from": "metrics.passing",

22+ "from": "metrics.pass_rate",

23 "as": "trend" },

24 { "kind": "synthesize",

25- "prompt": "Summarize {{metrics.passing}} and {{trend}}" },

25+ "prompt": "Summarize {{metrics.pass_rate}} and {{trend}}" },

26 { "kind": "deliver", "via": "email" }

Instant custom analytics dashboards

Generate custom performance dashboards on demand using live execution telemetry and dedicated system endpoints.

// Next.js: output: 'export', then npm run build
deploy_wfp({ dir: "/work/app/out" })
// Live URL: https://<slug>.apps.51ultron.com

export default {
  fetch(request, env) {
    return env.ASSETS.fetch(request);
  },
};

Conversational routine control

Interact directly with dedicated automation channels to adjust schedules, query execution history, and inspect repair logs.

const r = await fetch(`${env.ULTRON_BASE_URL}/api/chat/v2`, {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "x-wake-conversation": auto.home_conversation_id,
  },
  body: JSON.stringify({
    message,
    conversationId: auto.home_conversation_id,
    bg_trigger: true,
  }),
});

Frequently asked questions

What is an automation?

Standing work you set up once, in a sentence. It runs on a schedule, a webhook or an email, with a home conversation, a health status and a full run history.

Does it call the model on every run?

No. A recipe runs as code on the engine, so a scheduled check costs nothing. The model is called only at the steps that need judgment or writing, and to repair a run that failed.

How do I change one?

Say what should change in its conversation, for example that you would rather get an email, and the recipe is updated in place.

Can it send something without asking me?

Nothing goes out by default. An approval gate pauses the automation and waits for your yes before it sends the thing that matters.

What happens when a run fails?

Three failures in a row open a repair turn in its home conversation. Ultron proposes the fix and waits for you, or repairs and tests it on its own if you allow it, with two attempts a day.

Where does the recipe live?

On the engine, with every version kept. With a repository connected, each version is also committed as automation.json, so every repair shows up as a diff you can read.

How is it different from a scheduled task?

Reading one source and summarizing it on a cadence is mechanical, so it becomes an automation that runs without the model. A scheduled task is for work that needs several tools and fresh judgment on every run.

Can I try one before it goes live?

Yes. A preview runs the recipe once with every outside effect held back, and the confirmation shows what each run is expected to cost.