🔖Shortcuts

A name, never a copy#

A shortcut gives a short name, like @brand-voice, to something that already exists on the platform: a Library note or prompt, a Company Memory document, or the Co-Pilot memory. The platform keeps the shortcut, not a copy: each time it's used, it reads what it points at, as the person using it, and brings in only what that person may see.

Open them from Prompts & context → Shortcuts, or press Ctrl K and type @ to list them.

Creating one#

• Type. *Context* brings in what it points at with your rules. *Resource* brings it in as it is.
• Handle. What people type after @: lowercase letters, numbers and hyphens. One handle means one thing in the whole organization, and the built-in names are taken.
• Shared with. *Private* (only you), *Project* (everyone, filed under a project) or *Company* (everyone; set by an administrator).
• What it points at. Up to 10 items, each required or optional.
• When something is missing. *Stop*, *Ask a person* or *Continue with a note*.
• Budget. The most it may add, in tokens (8,000 by default).

Guaranteed rules and instructions#

Every rule says how it's enforced:

Testing#

Test resolves the shortcut now, as you, and shows what it found, each item's state, the size against the budget, how many secrets were hidden, and the exact text the AI would get, wrapped as data rather than instructions. Running it again says what changed since the last test.

A shortcut is Broken when a required item was deleted or moved, and Switched off when its owner turned it off. Neither resolves until it's fixed or switched on again.

Using one in a run#

In a run's task (the run sheet, or the run panel on the Canvas), type @ and pick a shortcut from the list under the cursor, or keep typing its name. A shortcut shows highlighted in the text; Backspace right after it removes it whole. An e-mail address or a social media handle, like ana@loja.com or @allavanco, stays plain text.

Under the task, a panel shows what each shortcut would bring now, as you: its state, its size in tokens, anything cut or hidden, and the total. Inspect opens its Test.

• When the run starts, the platform reads each shortcut again, as you, and gives what it brings to the Root Orchestrator together with your task, marked as data, not instructions.
• If a shortcut can't be brought in (switched off, broken, over its budget), the run doesn't start: the panel says which and why.
• If a required item is missing and the shortcut says *Ask a person*, you're asked there: tick the box to run without what it couldn't bring, or fix it first.
• A task can mention up to 10 shortcuts, bringing at most 50,000 tokens together.

In agents' instructions and References#

On the Canvas, the instructions of the Root Orchestrator and of each Sub-Agent take @ too. A Reference can take its content from a shortcut: in the Inspector, choose Source → A shortcut, then follow its latest version or keep one.

• Just before each step, the platform reads that agent's shortcuts again, as the person who started the run, and gives them with the task the agent receives, marked as data, not instructions.
• Given upfront (the default) or On request: choose per agent, in the Inspector's *Context from shortcuts*. On request, the agent asks for it only when it needs it, so a big document it rarely uses costs nothing the rest of the time; an unattended step may not ask.
• If a shortcut can't be brought in (switched off, broken, not shared with the person running it), that step stops and the run says which one and why. Pre-Flight warns about it before you run.
• If a required item is missing and the shortcut says *Ask a person*, the run waits for you: Continue without it (the agent is told what's missing) or Stop the run.
• Rename a shortcut and the instructions still find it; the Inspector offers to update the text.
• A public app never uses shortcuts: its agents run without them.

In the Co-Pilot, type @ to name a shortcut in your request. It sees the names and descriptions of your shortcuts, never what they point at, and can make a Company Memory document of the design point at one.

The command palette: @ and /#

Press Ctrl K (⌘ K on a Mac):

• @ lists your shortcuts: *Suggested here* (this project's and the built-ins for where you are), *Favorites*, *Recent* and *All*. Enter inserts the shortcut into the text you were typing in, or opens its page. The star marks a favorite; favorites and recents are kept in your browser, only for you.
• /run: picks a workflow and opens the run sheet: the task, Simulation or Live, what a run usually costs and what is sent. Nothing runs until you confirm; the answer then appears on the Canvas.
• /open: opens a workflow, project, shortcut or guide. /show: shows the latest run, a recent run or the reports.

Actions only come from you choosing them here: /run: written inside a task or a document is just text.

Built-in shortcuts#

• @current-workflow: the workflow you're in, by the names of its agents, Skills, References and Connectors.
• @current-project: the project you're in: name, purpose, objective, workflows.
• @latest-run and @previous-runs: when runs happened, how they ended, tokens and time. Never their answers, which the platform doesn't keep.

Where it's used, and what runs used#

• A shortcut's Used by tab lists the workflows whose agents mention it or whose References point at it. Deleting it asks first, with that list: those steps stop until someone changes them.
• Its Usage tab shows what runs brought in through it in the last 30 days: how many times, how it went, about how many tokens, by workflow.
• A run's Context used, on its Run detail, lists which shortcut each step used, its version, its state and its size.

What is kept#

The shortcut's definition and versions (which items it points at, by id), and what the last test found: states, sizes and a fingerprint of each item's text. Never the text itself. Each test, and each use in a run, is recorded in the activity log, and what each run used is kept with its facts for 12 months (which shortcut and version, its state, size and fingerprints). What a run brings in stays in memory with the run (15 minutes) and isn't stored.

Coming next#

Next: files on your computer, shared documents and connected services' data, with the phases that connect them; then reports on how shortcuts are used.