Skip to main content

One thing leaves, and it is one sentence long

When somebody mentions an Agentick agent in Slack, labels a Linear issue for it, emails an agent that has an address, or messages an agent’s Telegram bot as its owner, the text of that message and the name of the channel it arrived on are sent to TypeSafe, who answer four narrow questions about it so that we can decide whether the message is work at all. That is the whole payload. Two fields:
The channel is the word slack, linear, email or telegram — not a channel id, not a thread id, not a Telegram chat id, not your workspace name, not an email address. The message is capped at 4,000 characters. For an email, the subject is the first line of the text; the sender and recipient addresses are not sent. A Telegram message counts only when it comes from the person who made the agent’s bot; anyone else is told the agent is private.

Why we send anything at all

Without this, every message addressed to your agent becomes a case: a greeting spends a turn of your own model subscription, takes seconds instead of milliseconds, and bills you for a unit of work that was somebody saying hello. The classifier answers four questions — is the author asking for something, is it aimed at the agent, what kind of message is it, is there enough here to start on — and our own code combines those answers into the decision. We never ask the model “should this open a case?”; the policy stays ours, in a function you could read in a sitting.

What never leaves

The list of nothing else is the part worth reading:

Never sent

  • Repository contents and file diffs
  • Prompts sent to a model, and the completions that come back
  • Your agent’s persona or configuration
  • Any prior case, ticket or conversation
  • The reporter’s identity, user id or email
  • Channel ids, thread ids, workspace names
  • Environment variables
  • Credentials of any kind

Sent

  • The message text (≤ 4,000 characters)
  • The word slack, linear, email or telegram
That is what reaches the classifier, or any third party, on its own. The rest of this page is what moves only because someone chose it: the agent publishing a file to a case, a tool an admin connected, and a person watching the agent’s computer live.

Whose key, and whose bill

Ours. This is the one inference call our cloud makes, and we pay for it. It does not touch your model budget and does not appear on your spend. Model spend for the actual work is unchanged and unaffected: your key, your machine, direct egress to your provider.

When it fails

The classifier is a third party, and third parties have bad days. Every failure — outage, timeout, rate limit, expired key, malformed answer, or an answer the model itself is not confident about — resolves the same way: the case opens anyway, and is recorded as unclassified. Nothing is inferred from a failure. A message we could not classify is treated exactly as it would have been before the classifier existed, because getting this wrong in the other direction would silently drop somebody’s real request.

Bots and the agent’s own messages

Never classified, and never sent. Messages from bots — including the agent’s own posts — are discarded before the classifier is reached. That is structural rather than a rule someone remembered to write, and it is what stops an agent from classifying its own replies in a loop.

Email, for agents that have an address

Email is only active once an admin has connected your workspace’s own AgentMail account at Integrations and set up an address on your domain for the agent. For every other agent, nothing is sent to any email provider. AgentMail is your own vendor, like your Slack app, not our sub-processor. The agent’s mailbox lives in your AgentMail account, under your agreement with AgentMail; mail content passes between that account and our API for the agent’s work, the way Slack messages do. We hold your AgentMail key sealed and use it only to set up your domains and each agent’s inbox, and each agent’s own key, which reaches only its inbox. See Sub-processors. In our own database we keep metadata only: message ids, addresses, the outcome and send records. The case holds the triggering message the way it holds a Slack message. Audit records never contain message bodies. Only mail addressed to an agent that has an address, and that passes our admission rules, is sent on to the classifier. Mail AgentMail categorises as spam, blocked or unauthenticated is never subscribed to, so it never reaches an agent. Message bodies are treated as untrusted input.

Files on a case

An agent can look at the files people hand it and post files back. Each one is a case file, stored in our own AWS account (the same sub-processor that holds your cases; no new one) and deleted after 30 days:
  • Screenshots, documents and attachments shared in the case’s Slack thread, on its Linear issue, in its GitHub issue or pull request, in an email to the agent, or in its Telegram chat (on Solo and up).
  • Files a person attaches to the case on the dashboard.
  • Files the agent publishes from its desk on your machine, which it does only to post them somewhere or show them to you.
  • Recordings of the agent’s computer, which are off unless an admin turns recording on for your workspace.
Only images, PDF, text, Markdown, CSV, JSON, Word, Excel and PowerPoint documents, MP4 and WebM are accepted, judged by what the file is rather than what it is called, up to 25 MB (100 MB for video). Redaction. A text file the agent publishes is redacted on your machine before it leaves, like everything else the runner sends. Images, video, PDF and Office documents are not redacted: a secret in a screenshot cannot be found reliably, and rewriting the file would corrupt it. Files shared in Slack, Linear, GitHub, Telegram, email or the dashboard are stored as they were shared. The bucket is private and encrypted, and only our API reaches it. People who can see the case can download its files; a runner fetches one through a one-time link that lasts ten minutes. Every file added, fetched, published, posted or downloaded is recorded in the audit log with its name, size and where it came from or went, never its content. When the agent posts a file to Slack, Linear or Telegram, that copy lives there under your agreement with them.

Tools you connect

When an admin connects a tool for the workspace, its keys go into our cloud from the admin’s browser, not out of your network. The secret ones are encrypted with AWS KMS in our AWS account as they are saved and never shown again. For each piece of work an agent is given the tool, the keys go to your runner sealed to its own encryption key, and from there to the agent’s coding tool. See If you connect a tool. What the agent then reads or writes in that tool goes between your machine and the tool directly. None of it passes through us, and the tool is a vendor you chose, under your agreement with them, not one of our sub-processors.

The live view: the screen, when someone watches

Only when a person in your workspace opens an agent’s computer live, its screen leaves the box, and that person’s input reaches it while they hold control:
  • By default, through Cloudflare, encrypted. The stream is WebRTC, encrypted between the box and the viewer’s browser (DTLS-SRTP), relayed by Cloudflare’s TURN service, which cannot decrypt it. Cloudflare sees the two ends’ IP addresses and ports, and the timing and volume of the traffic. It sees no case content, no names and no workspace. See Sub-processors.
  • On a network that blocks that path, through our servers, readable. The view falls back to a relay through our own servers, which can see the screen and what the person types while it is open, and the view says so in a banner. We store and log none of it; we count its bytes for the audit log.
Nothing on the screen is hidden. Redaction works on text and cannot work on pixels. Whatever is on the agent’s screen is what the viewer sees. Nothing is recorded unless an admin turns recording on for your workspace; a recording is then a case file, above.

What your Mac tells us about itself

Separately from classification, your runner reports on its own health so that “the runner went offline” comes with a reason. This goes to our own cloud only, kept in your workspace — no third party receives it. Always: operational events. The runner, its box and the desktop app record what happens to them — starting, stopping, crashing; the Mac sleeping, waking or losing the network; an update or a box replacement and how it went; the connection to us dropping and coming back. Each event is a code from a fixed list, a level, a time, one short sentence and a few small values like an exit code or how long something took. It may name the case and step it happened during, by id.

Never in an event

  • Case content: messages, tickets, replies
  • Prompts and completions
  • File contents
  • Command lines
  • Credentials of any kind

In an event

  • Which part reported it: the desktop app, the box, the runner
  • What happened, from a fixed list, and when
  • A short sentence and up to 20 small values
  • Versions, and the case and step ids if any
Events are redacted on your Mac before they leave it, like everything the runner sends. Your workspace’s admins can read them on each runner’s Timeline in the dashboard. Only when a person asks: logs and the support bundle. Log text and the runner’s support bundle stay on your Mac until one of two things happens:
  • Someone at the Mac presses Send diagnostics in the desktop app, which shows what is included before it sends.
  • An admin of your workspace presses Request diagnostics on the runner’s page in the dashboard.
Either way, everything is redacted on your Mac before upload, and the support bundle never contains credentials, prompts or source code. Nothing else sends them: no schedule, no setting, no default. See Retention for how long both are kept.