# Automations

> Turn a sentence into an authenticated API call — the model works out the parameters, Triplo fires the request.

Source: https://triplo.ai/docs/automations  
Last updated: 2026-10-18

## What an Automation is

An Automation is an HTTP request you have described to Triplo once — a URL, a method, headers, a body — with named parameters left blank. When it runs, the model reads what you wrote, works out the values for those parameters, and Triplo fires the request.

You write *"log a lead for Maria Santos at Northwind, she wants the enterprise tier, high priority"*. Your CRM gets a properly formed record.

### The shape of it

*Diagram: How an automation turns a sentence into an API call*

- **You write**: a normal sentence
- **Model extracts**: parameters as JSON
- **You confirm**: and can edit values
- **Request sent**: result in the chat

> **Warning:** An Automation performs a **real action on a real system**. Keep Confirm Automations switched on — it is on by default — so you always see the values before anything is sent.

## Creating one (Paid plan)

**How to reach it.** Action grid → Automation → Add Automation…. The editor has two steps.

### Step 1 — what it does

- **Function Name ***: Distinctive, no spaces needed — `CreatePipedriveLead`. The model is told this name, so make it describe the action.
- **Description ***: What it does and when to use it. The model reads this to decide what the parameter values should be — this field does real work, so write it carefully.
- **Parameters ***: At least one. Each has a name and a description. The description is the instruction to the model about what to put there.

### Step 2 — where it goes

- **URL ***: The endpoint. May contain `{{parameter}}` placeholders, URL-encoded when substituted.
- **Method**: `POST`, `GET`, `PUT` or `DELETE`. Defaults to POST.
- **Headers**: A JSON object. Authorisation goes here. Must parse as valid JSON.
- **Payload**: A JSON body, with `{{parameter}}` placeholders. Ignored for GET and HEAD. The wand button generates a starting payload from your parameters.

Both JSON fields are validated when you save, so a malformed header block is caught in the editor rather than at 2 a.m.

## How parameters get filled

This is the part worth understanding, because it explains both the power and the failure modes.

When a prompt carries an Automation, Triplo adds a system message naming the automation, repeating your description, listing every parameter with its description, and instructing the model to reply with **only** a JSON object mapping parameter names to values — no prose, no code fences.

The model's whole reply for that turn is that JSON. Triplo extracts the object (tolerating a stray code fence or sentence), substitutes the values into your URL, headers and payload, and sends the request.

```
// You typed:
Log a lead for Maria Santos at Northwind Trading, she wants
the enterprise tier, high priority, found us via the webinar

// The model returned:
{
  "name": "Maria Santos",
  "company": "Northwind Trading",
  "interest": "Enterprise tier",
  "priority": "high",
  "source": "webinar"
}
```

Substitution is escaping-aware: values placed inside a JSON payload are escaped so quotes and newlines cannot break the document, and values placed in the URL are percent-encoded.

### The confirmation step

With Confirm Automations on, a dialog shows every extracted value before anything is sent, and lets you **edit them**. This is where you catch a misread company name. Cancelling reports back in the chat and sends nothing.

Turning confirmation off makes automations fire silently. Only do that for automations whose effects are trivially reversible.

### Why extraction sometimes goes wrong

- **Vague parameter descriptions.** "The date" invites any format. "The due date in ISO 8601 format, e.g. 2026-03-14" gets you one.
- **Missing information.** If your sentence never mentions a priority, the model guesses. Say what should happen when a value is absent.
- **A chatty model.** Smaller models sometimes add an explanation despite being told not to. Triplo strips code fences and surrounding prose, but a model that refuses to emit JSON at all will produce an empty parameter set. Use a more capable model for automations.

## Running one

Automations are not invoked by name from the prompt bar. They attach to a **SmartPrompt** as a [Magnet](https://triplo.ai/docs/magnets). That is the only way to trigger one.

1. **Create the automation**: As above. Make sure its toggle is on — an inactive automation never runs.
2. **Create or edit a SmartPrompt**: Something that describes the input, such as *"Log this as a new sales lead."*
3. **Attach it as a Magnet**: In the prompt editor, set the **Automation** magnet to your automation. Save.
4. **Use the prompt**: `/lead`, then your sentence, then `Enter`. Confirm the values. The result is reported in the chat with its HTTP status.

Give that SmartPrompt a hotkey and the whole thing runs from anywhere: select a paragraph from an email, press the key, confirm, done.

## Worked examples

### Post to a Slack channel

- **Name**: `PostToTeamChannel`
- **Description**: Posts a short update to the team's Slack channel. Use for status updates, announcements and handovers.
- **Parameters**: `message` — the text to post, written in full sentences, under 300 characters, no markdown headings.
- **URL**: `https://hooks.slack.com/services/T000/B000/XXXX`

```
Payload
{
  "text": "{{message}}"
}
```

### Create a task in a tracker

- **Name**: `CreateTask`
- **Description**: Creates a task in the engineering backlog from a description of work that needs doing.
- **Parameters**: `title` — imperative, under 80 characters. 
`body` — context and acceptance criteria, Markdown allowed. 
`priority` — exactly one of: low, medium, high, urgent. Use medium if unclear.

```
Headers
{
  "Authorization": "Bearer YOUR_TOKEN"
}

Payload
{
  "title":    "{{title}}",
  "body":     "{{body}}",
  "priority": "{{priority}}"
}
```

Note how `priority` constrains the model to a fixed set *and* says what to do when the input is ambiguous. That single line prevents most bad values.

*Animation: The fallback is not a setting — it is the parameter description you wrote, and the model followed it.*

### A lookup with GET

For a read, put the parameter in the URL and leave the payload empty:

```
URL
https://api.example.com/customers/search?q={{query}}

Method
GET
```

The value is URL-encoded on substitution, so spaces and punctuation are safe.

## Limits & gotchas

- **The response is replaced.** When an automation is attached, the model's reply is the parameter JSON, not an answer. You see *"Captured parameters for …"* instead. An automation-carrying SmartPrompt cannot also produce prose for you.
- **One automation per prompt.** Chain them by running a second prompt.
- **Responses are truncated to 4,000 characters** in the chat. The request still completed in full.
- **Requests are sent from the app, not a browser**, so CORS never applies. Your endpoint does not need to allow browser origins.
- **Credentials live in the headers field**, stored in a Markdown file in your Documents folder. Anyone with access to your disk can read them. Use scoped tokens with the narrowest permissions that work.
- **Shared automations are read-only.** An automation shared from another device — including its headers — cannot be edited until you clone it.
- **Failures are reported, not retried.** A non-2xx status shows in the chat with the status code. Run it again after fixing the cause.
- **Test against something harmless first.** A request bin or a scratch channel will save you an embarrassing message in a real one.