Skip to main content
Agentick is two halves, and which half holds what is the whole security story. The cloud owns judgment and identity. Deciding that a ticket is actionable, what to ask the reporter, when to escalate, what the agent says and where it says it, what it cost. Your runner owns execution and secrets. A signed binary on a machine you own. Cloning, branching, editing, building, running tests, opening the pull request — and every credential, while the agent is using it.
This split is invisible from the outside, on purpose. A colleague’s laptop and their phone are both them. Which half of our system types a Slack message does not change who is speaking.

What that buys you

The connection is outbound, from you

Your runner dials us and holds the connection open. There is no inbound path from our network into yours, no port to open, no firewall exception to request, and no address of yours that we know. Work is leased to the runner over that connection; if the machine sleeps, the lease expires and the work is offered again.

The agent works under its own identities, never your logins

Each agent has its own GitHub App, and the AWS roles you connect and give it. For each piece of work we mint a short-lived token from the App, narrowed to the agent’s level (Read only, or Read and change), and hand it to your runner; pull requests and commits are the agent’s bot’s, not a person’s. The App’s private key never leaves us, and uninstalling the App or disconnecting it on the agent’s page revokes it at once. If a token can’t be issued (the App isn’t installed anywhere yet, say), the work still runs with GitHub shut out — never on the machine’s own login — and the agent says why. Every credential we hand a runner (GitHub tokens, AWS sessions, the keys of a tool you connect) travels over its encrypted connection to us. From runner 0.2.23 it is also sealed to that runner’s own encryption key, so only that runner can open it, and only for the piece of work it was issued for. A runner older than that is never sent a connected tool’s keys, and the agent is told why.

Where the agent’s work is isolated

On macOS 26 the whole runner runs in an isolated Linux box on your Mac (Apple’s container, or a Docker engine): your files, Keychain, SSH keys and logins do not exist inside it; only the folders the agent works in are shared. Each case’s work runs as its own user in the box, so one case cannot read another’s credentials or the runner’s own, and by default agents cannot connect to your Mac or your local network. The coding tool is signed in inside the box, separately from your own login on the Mac. A runner can also run directly on the Mac, which is weaker. See Known gaps.

If you give an agent AWS

You connect each AWS role once for your workspace (Integrations → AWS) and give it to agents one at a time. You create the role in your own AWS account; its trust policy names Agentick’s AWS principal and an external id unique to that connection. The connection’s page shows both, and the exact policy to paste. For each piece of work we assume the role for one hour, narrowed to AWS’s ReadOnlyAccess when the agent is set to Read only, and hand that session to your runner. Nothing long-lived is stored on your machine. Every call appears in your CloudTrail under the session agentick-<agent>-<case>, and deleting the role revokes us at once.

If you give an agent Linear

On the agent’s Tools tab, Linear is Off or On. On, the agent uses Linear as itself: its own Linear app, the one that answers in its Linear sessions, through Linear’s own MCP server, called from its box on your machine. For each piece of work we mint a Linear token from the app, seal it to your runner like any other credential, and revoke it when that work ends; the app’s client secret never leaves us. What the agent reads and writes in Linear goes between your machine and Linear directly, not through us, and it can do there whatever its app user can. A runner too old to connect the agent to Linear’s server is not sent a token, and the agent says the app needs updating.

If you connect a tool

Some tools are connected once for the whole workspace and then given to agents one at a time (the list is under Integrations). An admin enters the tool’s keys under Integrations, and a department lead or above chooses, on each agent’s Tools tab, whether that agent may use it.
  • Where the key is kept. Secret fields are encrypted with AWS KMS, in our AWS account, as they are saved, and are never shown again: not to admins, not in the dashboard, not in any response from our API. Plain fields (for Langfuse, the public key and the address) stay readable, so people can tell connections apart.
  • How it reaches the agent. For each piece of work, our cloud seals the keys to your runner’s own encryption key, bound to that runner, that piece of work and its lease, so only that runner can open them and only for that work. The runner gives them to the agent’s coding tool as environment variables for that step only. They are never given to the runner’s own commands, and redacted from anything the runner sends us. Apart from the hour-long tokens in the next point, they are never written to disk.
  • Tools whose key we keep and mint from (Google, Xero, QuickBooks). The service account key, client secret or authorization stays in our cloud, sealed as above, and is never sent to your runner. Our cloud asks the vendor for a token that lasts about an hour, made with only the scopes of the level you chose, and seals that token to your runner like any other credential. The runner writes it to a private file for the case, renews it before it expires, and deletes it when the case ends; the agent’s tool reads it from that file. Our cloud’s own request to the vendor carries the key and the scopes, and nothing of your data.
  • Where the traffic goes. The agent calls the tool from your machine, directly. Nothing it reads there passes through us. Under the Strict network setting, the tool’s address is allowed only while a step holding its key runs.
  • Rotating and removing. An admin can rotate a secret, after which the old value is gone, or remove the connection, which destroys its stored secrets and takes it from every agent at once. The connection’s name and plain fields stay on record. Every change is in your audit log with who made it, never a value.
What an agent can do with a connected tool is what its key allows. See Known gaps.

The live view: watching and taking control

An agent that runs in the isolated box can have a computer of its own: a browser, or a full desktop. A person can watch its screen live and take control of it, for example to sign in somewhere the agent cannot.
  • Who can. Department leads and above can watch. Taking control needs an owner or an admin, or a member an admin has given that permission. Every view and every takeover is recorded in your workspace’s audit log, which cannot be edited.
  • How it travels. The screen, and your input while you hold control, go as an encrypted WebRTC stream (DTLS-SRTP) between the box and your browser. By default it is relayed only through Cloudflare’s TURN service, which forwards traffic it cannot decrypt, and neither end learns the other’s address. The credentials for it are minted for each viewer, last 15 minutes, and are revoked when that viewer leaves.
  • When that path is blocked. On a network that blocks it, the view falls back to a relay through our own servers, which can see the screen and what you type while it is open. The view says so in a banner, and nothing from it is kept.
  • Nothing on the screen is hidden. Redaction works on text, not on pixels, so whatever is on the screen, a password included, is what the viewer sees. Nothing is recorded unless an admin turns recording on for the workspace; see Files on a case.
How to use it.

What the agent is allowed to touch

Every agent is granted a specific set of tools — which repositories, which integrations, which commands. What happens when it wants something outside that grant is a choice you make per agent, not a fixed behavior: Refuse is deny-by-default, and it is what every agent runs on unless you change it. “Allow everything” exists because some of you asked for an agent that never gets stuck waiting on a tool it wasn’t given — it is never the default, it is never applied silently, and it is not offered on every coding tool we support (Codex has no equivalent flag, so it is refused on save for a Codex agent, with the reason shown rather than a setting that quietly does nothing).

If you give an agent an email address

Email is only active once an admin has connected your workspace’s own AgentMail account and set up an address on your domain for the agent. The mailbox then lives in your AgentMail account, your own vendor rather than our sub-processor, and it holds the agent’s messages as the system of record. Our cloud holds your AgentMail key sealed, and otherwise keeps metadata only — message ids, addresses, outcomes and send records — and the case holds the triggering message as it holds a Slack message. Agents without an address have no mailbox anywhere. See Sub-processors and What leaves.

Traces

Where run traces go is your choice at enrollment:
  • Our observability stack — the runner ships traces to us, redacted on your machine before they leave it, not filtered on arrival. By the time a filter on our side ran, the secret would already have crossed the wire.
  • Your own self-hosted instance — the runner ships full traces directly to your endpoint. We receive metadata only: step timings, states, outcomes, counts. Enough to render your dashboard and bill you; not enough to reconstruct your work.