Advanced Usage

Your whole setup is Markdown on disk. Edit it in your own editor, put it under version control, and build workflows that chain several features together.

Files as configuration

Triplo AI stores nothing in a proprietary database. Every SmartPrompt, Instruction, Automation and conversation is a Markdown file in your Documents folder, and the app watches those folders.

Save a file in your editor and the change is live in Triplo within about half a second. No import, no restart, no sync button.

~/Documents/Triplo AI/ ├── SmartPrompts/ # .md — watched, ~500 ms ├── Instructions/ # .md — watched, ~300 ms ├── Automations/ # .md — watched ├── History/ # .md — watched ├── Minds/ # folders — vault watched for re-indexing └── Shared/ # read-only, written by sync

What this unlocks

Bulk editing. Rename a term across forty prompts with sed. Reorganise tags with a script.
Generation. Emit prompt files from a template — one per client, one per product line.
Review. Read your whole prompt library as text, in a diff, in a pull request.
Sharing without the sync system. Send someone a .md file; they drop it in their folder and it appears.
Recovery. Deleted something? Restore the file from git or Time Machine.

Files whose name starts with _ are ignored. Use that prefix for templates and notes you want to keep beside your prompts without Triplo loading them.

Rules the watcher follows

Only .md files are read.
The filename is the id. Renaming a file makes a new item and removes the old one.
Saves from the app are rate-limited to one per second per file.
A file that fails to parse is skipped with a log entry — one bad file never breaks the rest.
Editing in the app rewrites the whole file, so hand-added fields the format does not define will be lost on the next save from the UI.

File formats

All four follow the same shape: a type header, a title, then sections separated by ---. Settings are **Key:** value lines.

SmartPrompt

# SMARTPROMPT ## Tighten --- ### Settings **Active:** Yes **Command:** tight **Type:** normal **Tags:** writing, editing --- ### Content Rewrite the following text to be shorter and clearer without losing any information. Return only the rewritten text, with no commentary. --- ### Magnets **Hotkey:** [Cmd+Shift+T] **Model:** [connection-id:model-id] **Instruction:** [instruction-id] **Mind:** [mind-id] **Automation:** [None]

Field	Rules
Title (the `##` line)	Required, up to 200 characters
`Active`	`Yes` or `No`
`Command`	The trigger after `/`
`Tags`	Comma-separated, up to 10
`### Content`	The template, up to 10,000 characters
Magnet fields	`[None]` or an id. Model is `connectionId:modelId`; allowance models use `__allowance__:modelId`

Whole file limit: 50,000 characters.

Instruction

# INSTRUCTION ## Backend engineer --- ### Settings **Active:** Yes **Tags:** work, code --- ### What Senior backend engineer. Python and Go. Postgres, Redis... --- ### How Lead with the answer, then the reasoning. Code first...

Title up to 100 characters, What up to 5,000, How up to 2,000. Both text sections are required. Files written by older versions using ### Context and ### Response Style are still read correctly.

Automation

# AUTOMATION ## CreateTask --- ### Settings **Active:** Yes --- ### Description Creates a task in the engineering backlog. --- ### Parameters - **title:** Imperative, under 80 characters. - **priority:** One of low, medium, high, urgent. --- ### Endpoint **URL:** https://api.example.com/tasks **Method:** POST #### Headers ```json { "Authorization": "Bearer YOUR_TOKEN" } ``` #### Payload ```json { "title": "{{title}}", "priority": "{{priority}}" } ```

Parameters are list items of the form - **name:** description. Headers and payload must be fenced json blocks and must parse.

Vault notes

Notes inside a Mind use YAML frontmatter rather than this section format. See Vault reference.

Version-control your setup

Because it is all text, git works properly — real diffs, real history, real branches.

cd "~/Documents/Triplo AI" git init git add SmartPrompts Instructions git commit -m "Prompt library"

What to include

Folder	Track it?	Why
`SmartPrompts/`	Yes	The main reason to do this
`Instructions/`	Yes	Small, valuable, worth diffing
`Automations/`	Careful	Contains credentials in headers
`Minds/`	Usually not	Large, and the vault is regenerated
`History/`	No	Grows without limit; often sensitive
`Shared/`	No	Rewritten by sync every pull

# .gitignore History/ Shared/ Minds/*/vault/ Minds/*/files/ Minds/*/failed/ Minds/*/index.md Automations/

Automation files store API tokens in plain text. Committing Automations/ to a shared or public repository publishes those tokens. Exclude the folder, or strip the headers before committing.

Using it across machines

Clone the repository into ~/Documents/Triplo AI/ on each machine, pull, and Triplo picks the files up live. This gives every machine an editable copy, unlike Shares, which arrive read-only.

Don't run both at once for the same items — you will end up with two copies of everything, one editable and one not.

Power workflows

Four setups that chain several features together.

The house-style rewriter

Combines: Mind + Instruction + Magnets + hotkey.

Build a Mind from approved copy — past campaigns, the style guide, phrasing legal has signed off.
Write an Instruction stating your tone rules and, importantly, what to avoid.
Create a SmartPrompt: "Rewrite the following in our house style, drawing on approved examples. Return only the rewritten text."
Pin the Mind, the Instruction and a strong model as Magnets.
Assign a hotkey.

Anyone with that prompt now writes in your voice, from any application, in one keystroke.

Meeting notes to tracked tasks

Combines: Automation + Magnets + hotkey.

Create an automation against your tracker's API, with parameters for title, body and priority.
Create a SmartPrompt: "Extract the single most important action item from these notes."
Pin the automation and a model that reliably emits JSON.
Assign a hotkey.

Select a line from your notes, press the key, confirm the values, and the task exists.

The research desk

Combines: a Mind + URL import + the INGEST folder.

Create a Mind for the topic.
Collect sources as you go: paste URLs in bulk into the Mind editor, or drop PDFs into INGEST/.
Select the Mind and ask questions of the whole corpus.
Use the sources chip on each answer to check where a claim came from, and click through to the original.

The percentages are the Mind's own relevance scores — and the list is where the animation stops: in the app, clicking a note opens the original it came from.

The confidential setup

Combines: local model + local search + Magnets.

Add Ollama as a Connection.
Build the Mind while online so enrichment can run, then work offline afterwards.
Pin the local model to the prompts that touch sensitive material.
Do not attach images or audio to those prompts — media processing uses a remote endpoint.

Prompts, retrieved passages and answers all stay on the machine. See Local-only setup.

Custom and agent endpoints

Anything that speaks the OpenAI chat format can be a Connection, which includes more than model providers.

Gateways and proxies

Point Triplo at your organisation's LLM gateway for central logging, quotas and key management. Triplo never needs the upstream key.

Routing layers

Self-hosted routers that pick a model per request work transparently — Triplo sends the model name you selected and takes what comes back.

Agent frameworks

An agent exposing an OpenAI-compatible server becomes a "model" in Triplo, with its tools and memory behind it. This is how you reach an agent you run yourself; Triplo's own agent, Pi, needs no endpoint and is always in the droplist. Use raw pass-through to send commands verbatim; when such a connection is active, typing // also suggests that agent's commands.

Two requirements: GET /v1/models must list something, and POST /v1/chat/completions must accept the standard body. Streaming is optional — Triplo detects its absence and falls back.