Make

Tracira has a native Make app. Add monitoring to any scenario with a single module, no HTTP setup required.

Add the Send an output module to your scenario

In your scenario, click + after the module that generates the AI output. Search for Tracira and select Send an output. Tracira is an official Verified Make app, available to every Make account with nothing to install.

Connect your workspace

Click Add to create a connection. When prompted for an API key, paste your webhook token from the Integrations tab in your Tracira workspace.

Map the fields

At minimum, map project and output from the previous module. Optional fields:

task: groups outputs inside the project
input: the message the AI replied to (e.g. the customer's email) - not your system prompt
model, latencyMs, costUsd: for analytics
sync: set to true to get the verdict inline (gate mode)

Branch on the verdict (gate mode)

When sync is enabled, add a Router after the Tracira module:

Route 1, filter: {{tracira.status}} = pass then continue
Route 2, filter: {{tracira.status}} = flagged then alert or stop

Field mapping

// Send an output module fields
{
  "project": "{{1.project}}",
  "output": "{{1.aiOutput}}",
  "task": "Tone Validator"
  // sync left blank, returns id + pending instantly
}

Verdict response

{
  "ok": true,
  "id": "b1c2d3e4-...",
  "status": "pass",
  "verdict": {
    "pass": true,
    "rules": [{ "name": "Tone Validator", "triggered": false }]
  }
}

Logging a conversation

For a chatbot or support thread, send one output per exchange - do not paste the full message history into every output:

Input Text: only the newest user message (the one your AI just replied to)
AI Output: the reply to it
Session ID (under Advanced settings): your conversation or thread ID - the same value on every turn

Tracira stitches all outputs sharing a Session ID into a single conversation thread, so reviewers read the whole exchange in order with nothing repeated. Your AI request can still carry the full history - Tracira only needs the new turn.

Leave your system prompt out entirely: it's configuration, not conversation. The best place for it is Tracira itself - see Hosted instructions below.

Hosted instructions (self-improving prompts)

Tracira can host the instructions (system prompt) your AI runs with, so the prompt lives next to the people reviewing its output instead of buried inside a scenario module or a spreadsheet. Reviewers see, edit, and restore every version on the Instructions page in the dashboard; your scenario always drafts with the latest.

Fetch instructions at the start of the run

Add Tracira → Get instructions before your AI module. Use the same Project Name and Task Name as your Send an output module, and put your prompt into Starter Instructions. It is saved as version 1 on the very first run and returned; after that, whatever is stored in Tracira always wins. Map the module's Instructions output into your AI step's system message.

Tag each output with the version

In Send an output, map the Get instructions Version output into Instructions Version. Every output then shows "Instructions it followed" with a link to the exact text that produced it.

Teach it from feedback

When a reviewer sends a draft back with a comment (Watch decisions, Decision = changed), have an AI step rewrite the current instructions to follow that comment, then save the result with Tracira → Update instructions - map the reviewer's Comment and the Output ID so the dashboard shows why the version exists. The next run drafts with the improved instructions: the same correction is never needed twice.

[ Gmail ] → [ Tracira: Get instructions ] → [ AI drafts ] → [ Tracira: Send an output ]

Attaching files

For small files, map them into the Attachments field of the Send an output module. Pick Upload file and map the binary, or From URL and paste an HTTPS link. Tracira auto-detects whether each attachment is an image, audio, or document.

Large files: the Upload File module

Inline attachments travel inside the Send an output request, which is capped at 4.5 MB. For larger files (a multi-page scanned PDF, a high-res image) add the Upload File module before Send an output. It uploads the binary straight to Tracira storage (no size cap from the request body) and returns a key, supporting files up to 32 MB.

Add the Upload File module

After the module that produces the file, add Tracira → Upload File. Map the binary into File and its name into File name.

Add Send an output after it

In Send an output, under Attachments, add an item with source Tracira upload and map the Upload File module's Attachment Key output into the key. That is the only mapping needed; the file is linked to this output automatically.

[ AI module ] → [ Tracira: Upload File ] → [ Tracira: Send an output ]

Why two modules

The file is uploaded directly to storage, bypassing the request-body limit, then the output references it by key. This is the same flow any client uses through the public API (POST /api/uploads, then POST /api/logs), just packaged as a module.

Getting a file back: the Download File module

Every event on the Watch decisions trigger carries an Attachments array listing the files stored on that output, each with a File Name, a File Key, and a File URL.

That is what makes a redo possible for document work. A scenario that parsed a PDF has finished long before the reviewer reads it, so when they send it back with a comment the scenario no longer holds the file. Add Tracira → Download File, map the attachment's File URL (or File Key) into File, and it comes back as binary data you can feed straight to your AI module along with the reviewer's Comment.

[ Tracira: Watch decisions ] → [ Tracira: Download File ] → [ AI module ] → [ Tracira: Send an output ]

On that final Send an output, set Revision Of to the original Output ID so the two versions form a chain, and under Attachments add an item with source Already in Tracira, mapping the same File Key. The document stays on the new version without being uploaded again.

Each version keeps its own copy

A re-attached file is copied into the new output rather than shared with the old one. Deleting an output deletes its files, so a shared file would disappear from the revision the moment someone cleaned up the original. It does mean a document revised three times is stored four times and counts four times toward your storage quota.

Tip

Leave sync blank for fire-and-forget logging (Make continues instantly). Set it to true only when you need to gate the scenario on the evaluation result.

On this page