The short version
Four questions, answered first
Does SpriteRelay upload my artwork?
No. Sprite Relay does not transmit your artwork, pixel data, project files, or local file paths to us through ordinary use. Core processing happens on your device. The separate matter of what your AI client sends to its provider is covered below.
Can the assistant run arbitrary code on my machine?
Not through us. Neither product exposes a raw-Lua or arbitrary-code channel. An agent submits typed, validated operations — anything not modelled as an operation simply cannot be requested.
Will it overwrite my source files?
Not without an explicit step. CLI works in a staged copy until you commit, and overwriting an existing file leaves a backup beside it. Live edits the open document but never saves it to disk for you, and a patch undoes in one step.
Do I need an account?
No. The software does not require a SpriteRelay account, and it does not collect, upload, transmit, or store personal data on our systems through its ordinary operation.
Where the work happens
What stays on your machine
Both products are ordinary local software. CLI launches the Aseprite you installed, in batch mode, on your disk. Live talks to a Bridge extension inside the Aseprite you already have open. Neither requires an account, and neither depends on a hosted Sprite Relay service to do its work — the processing happens where your files already are.
We receive personal data only when you send it to us yourself: an email about support, a refund, a security report, or a legal question. When that happens we use what you sent to answer you. We do not sell it, use it for advertising, or feed it into automated decision-making or profiling, and we keep it only as long as the request and any legal retention period require. The complete statement, including your access and deletion rights, is in the privacy section of the licence agreement.
The important distinction
Where we end and your AI client begins
This matters more than any single security control, and it is easy to blur, so here it is directly: your MCP client and the model behind it are separate software, made by someone else, operating under their terms and their privacy policy.
What you type into that client, and what the client decides to send to its provider, is between you and them. We do not control and are not responsible for the prompts it sends, the outputs it returns, or the data it collects, stores, or transmits.
The practical takeaway: review your client's settings and privacy practices before you point it at sensitive project files. SpriteRelay running locally does not make your AI client local, and we would rather say so plainly than let the word "local" do more work than it should.
Live only
How Live reaches your open document
Live reaches the editor through the matched Bridge, an Aseprite extension shipped as readable Lua source. The server and the Bridge talk over a token-authenticated localhost connection carrying JSON control messages. It is not a public network service, and if you do not use Live, nothing of the sort exists on your machine.
Aseprite asks your permission twice on first run — once for the Bridge's outbound connection and once for file access. Those are Aseprite's own prompts, not ours, and nothing connects until you accept them.
Because the Bridge ships as source rather than a compiled blob, you can read exactly what it does. Your licence lets you inspect it for security review, troubleshooting, debugging, compatibility analysis, interoperability, and learning, and modify it locally for your own use. You cannot redistribute it, and we are not obliged to support a Bridge you have modified.
To be precise about what this buys you: these are risk-reduction measures, not guarantees. We do not warrant that unauthorised access, malware, a compromised device or operating system, token disclosure, or a network misconfiguration cannot happen. Your device, account, credentials, tokens, and client configuration remain yours to secure.
The design
The agent can only do what the operations allow
An assistant working through SpriteRelay does not get a scripting console. It submits typed operations from a fixed vocabulary, and anything outside that vocabulary is not expressible — not discouraged, not filtered, just absent. Around that:
- Values are validated before execution; strings are escaped or passed as explicit script parameters, and generated scripts are checked for restricted tokens.
- Every path you supply goes through a path guard.
- Aseprite subprocesses launch with explicit argument arrays, no shell, enforced timeouts, and bounded output buffers.
- Standard output is reserved for protocol traffic; logs go to standard error as structured JSON, so a noisy log cannot corrupt a response.
One honest limitation. Our server restricts its own behavior, not your client's. It is launched over stdio by that client and inherits its operating-system privileges, so it cannot sandbox the client or stop it from using its own separate file, shell, or network capabilities. If your client can already write files, SpriteRelay's boundaries do not change that.
Your files
Nothing becomes permanent by accident
Both products are built so a change is reviewable before it sticks, in two different ways.
Live edits the document open in Aseprite and does not save it for you. A patch against an existing document forms a single labelled native undo step, so one press of undo removes the whole change — creating a new document is the stated exception. If a change is interrupted partway, it is flagged as uncertain rather than replayed behind your back.
CLI works in a staged copy, so your project files stay untouched until you explicitly commit. Staged work can simply be discarded. Committing over an existing file leaves a backup beside it; manifest commits write a durable journal before touching anything, can verify afterwards whether destinations are intact, drifted, or incomplete, and can be rolled back from that journal. The technical reference walks through each mode.
What this is worth, stated accurately: temporary workspaces, staging, path validation, backups, atomic writes, journals, rollback, operation validation, and restricted subprocess execution all reduce the chance of losing work. They are design measures, not guarantees. Data loss, corruption, incomplete writes, unexpected edits, permission failures, hardware or operating-system faults, application or dependency defects, client errors, and plain configuration mistakes remain possible. Keep your own backups and check results before you depend on them.
Diagnostics
What gets logged, and where it goes
The software can record optional local diagnostic or usage information when you turn that on. Unless we have expressly said otherwise, it stays on your device, is not transmitted to us automatically, and can be cleared with the built-in cleanup functions or by deleting the files yourself.
If you choose to send logs, diagnostics, screenshots, or project files with a support request, we use them to investigate and reply. Strip anything confidential or unnecessary before you send it — good practice with any vendor, us included.
Honesty
What we don't claim
Security pages are usually written to reassure. This one is meant to be checkable, so here is what is deliberately absent: we claim no absolute security, no zero risk, no security certification or audit, no regulatory compliance certification, and no encryption guarantee. Where something is a design intention rather than a promise, this page says so in that sentence rather than in a footnote.
We also cannot guarantee compatibility with future or modified versions of Aseprite, Node.js, operating systems, the MCP specification, or third-party clients.
The licence agreement is what actually controls these terms — including the privacy notice, the warranty disclaimer, and the file-safety disclaimer. Security reports go to the contact named in the SECURITY.md file supplied with each product; anything else can go to support@spriterelay.com.