Skip to content

Agent security

Donkit Guard watches two moments of every agent turn: what the agent is about to send to a model, and what it is about to do with a tool. Depending on the mode you choose for your account, it records what it sees, masks secrets and personal data, and asks you before an agent takes an action with consequences.

What it does

  • Keeps secrets out of models. API keys, tokens, passwords and similar credentials found in a message, a document or a tool result are replaced with a placeholder before the text reaches any model. The original text stays in your conversation, and your own message shows which parts the model did not get; only the copy sent to the model is masked.
  • Keeps personal data inside the platform. Names, contact details and identification numbers are masked before they reach a model that runs outside the platform, such as your own model provider. Platform models receive them unchanged, and the finding is recorded.
  • Asks before side effects. Deleting or editing files, sending email, writing to a spreadsheet, running code with network access, spending credits on media — the agent pauses and shows an approval card in the chat to the person who asked for it. They Allow or Reject; if nobody answers within five minutes, the action is not run. Reading files, searching, and running code in the sandbox without network access do not ask.
  • Records every decision. The Security page lists what the guard allowed, masked, blocked or asked about — with the agent, the user, the tool or model, what it found, the rule and the reason. For a visitor of a published agent, an entry does not say which conversation or which record, address or file the action was about. You can narrow the list by outcome.
  • Follows your rules. An account owner or admin describes the organization's own rules in plain words — forbid a tool, make an action ask for confirmation, mask more than the platform does — tries them on one action, and every agent of the account follows them.
  • Learns your own data. Contract numbers, client names, project code names, anything else only your organization has: describe it with examples, with a list of words or with a service of your own, and choose whether the guard masks it before models, blocks it in tools or only records it. See Your own data.

Modes

Open Settings → Security. The mode applies to every agent of the account within about half a minute:

  • Off — nothing is checked or recorded.
  • Observe — everything is checked and recorded, nothing is blocked or masked. Use it first to see what the guard would do; the list marks the entries that Enforce would have blocked.
  • Enforce — secrets are masked, personal data is masked before outside models, and actions with side effects wait for your approval.

New accounts start in the platform default, which the Security page shows: Off, unless your installation sets another one. Only an account owner or admin can change the mode. Everything on this page applies to the agents of an account from the moment it is in Observe or Enforce.

The same goes for the checks the platform runs on your agents' conversations by itself: the judge that rates how an agent's users react to its answers, and the checks and summaries behind the Builder's statistics. What they send a model follows your mode and your rules, as your agents' own requests do.

The Donkit assistant and the built-in agents come with the platform, not from your account, so your mode and your own rules do not apply to them: they run in the platform default mode.

Your own rules

Below the mode, the Security page asks you to describe what your agents may and may not do — in your own words, one thought per line:

Nobody may delete files.
Sending email always asks the person first.
No customer data to models outside the platform.

Draft rules turns the description into a list of rules and shows each one before anything is saved. Every card says, in one sentence, what the rule does — Blocks the tools delete_file. Nobody can confirm past it. — along with the reason a user will read when the rule stops them. Keep the ones you want with the checkbox and leave the rest out.

The sentence names every condition of the rule — which actions it covers, what has to be found and how sure the check must be, who is acting, which models — so a rule never does more or less than its card says. A rule that blocks personal data only when an agent sends it out through a tool reads: Blocks what is found as personal data with confidence at least 0.5 in tool calls whose effect is egress. Nobody can confirm past it.

Two things a card can say instead:

  • This one cannot be used. The rule named a tool your account does not have, listed more than 50 tools or more than 50 kinds of finds (one pattern such as jira_* stands for many tools), reused a platform rule's name, left out the reason a blocking rule needs, or would block personal data in messages to models (see below). The problems are listed and the rule cannot be kept until the description says something the guard can actually do.
  • No rule can express this. Your sentence is quoted back with why it does not fit — the guard sees roles and tools, not job titles or people by name — and the nearest rules it can express are offered to pick from, or to skip. Nothing is silently substituted for what you asked.

Your rules are combined with the platform rules, and the stricter setting always wins: a rule of yours can forbid an action or make it ask for confirmation, but it can never relax a platform rule (secrets stay masked, side effects still ask). The mode is set with the switch above, not by a rule.

Every organization starts with one rule of its own: people outside it — visitors of a published agent, API clients and other agents calling yours — may not take actions with side effects. It shows up among your rules like any other, and you can delete it; visitors then confirm such actions themselves.

Drafting asks a model to read your description, so the wording of the answer varies and the hourly number of drafts per account is limited. What the page shows is not the model's word for it: the sentence on each card is built from the rule itself, and the platform checks every rule before you can keep it.

Personal data in messages to models

Personal data in what an agent sends to a model can be masked, but not blocked. An agent's instructions say who it is talking to — the person's name and email — so a rule that blocks personal data in messages to models would stop every conversation before the agent could answer. Ask for such a rule and the draft gives you the rule that masks personal data instead: it is replaced before every model, platform models included, and the conversation goes on. A blocking rule of that kind is marked This one cannot be used.

Messages can also mean what an agent sends out through its tools — an email, a post in a messenger. When your sentence could mean either, both readings are offered to pick from: mask personal data before every model, or block the tool calls that send personal data out.

Trying a rule before you save it

Try it before saving answers what the guard would do with one concrete action under the rules you have just assembled — before any agent runs under them. Pick a tool and its arguments, or write a message an agent would send to a model, and press Run. The answer is Blocked, Asks the person, Masked or Allowed, with the rule that decided it and the reason. A masked message also shows the text the model would have received. Nothing is sent to a model and nothing is added to the decision list.

Detectors you have added or changed under Your own data and not saved yet take part in the answer. When the guard finds something in the action, the answer lists it: which detector found it, where (the tool's argument, or the message) and the text it found. A detector that did not answer is named too, because what it would have found is then unknown, not absent. If a rule uses a service of your own, the text you typed is sent to that service, just as a real action would send it.

While the account is in Observe or Off, the dry run answers as Enforce would — it is there to tell you what switching the mode on will change.

The rules you have

The Organization rules card lists the rules the account runs on now, one card each, with Delete to drop one. While you have unsaved changes the card shows the rules the account would run on, and Save as version N stores them; Discard throws the changes away. A save applies to every agent of the account within about half a minute, and cancels approvals still waiting for an answer — they were asked under the previous rules.

Advanced: the document itself

Rules are stored as a short YAML document, and Advanced at the bottom of the page opens it: the text editor, the version history and the full table of effective rules. Edit it directly when a rule needs a selector the description cannot reach.

Each rule has an id (unique, lowercase, dashes), a match block, an action and a reason. deny with hard: true cannot be overridden by an approval. Three examples:

schema_version: 1
layers:
  - name: organization
    rules:
      # Agents never write to Jira; the glob matches every tool of the server.
      - id: org-no-jira-writes
        match: {action_kind: [tool_call], tool: ["jira_*"]}
        action: deny
        hard: true
        reason: "Jira changes are made by people, not agents"

      # Running code always asks, even without network access.
      - id: org-python-needs-approval
        match: {action_kind: [tool_call], tool: [python_exec, run_file]}
        action: require_approval
        reason: "Running code needs confirmation in this organization"

      # Personal data is masked before every model, platform models included.
      - id: org-mask-pii-everywhere
        match:
          action_kind: [llm_request]
          finding_class: [pii]
          min_score: 0.5
          destination_trust: [platform, tenant, unknown]
        action: mask
        reason: "Personal data is masked before any model"

The selectors you can use in match are listed in the document's own comments (tool name, effect, who is acting, where the data goes, what the detectors found). Check validates the text and previews the rules it adds; Save stores it as a new version. Every problem is reported with where it sits — the line for a syntax error, the path of the rule (layers/0/rules/1/reason) or of the detector (detectors/0/patterns/0) for anything else — and a document that does not validate is never applied.

The version history keeps every saved document; Roll back makes an earlier one active again. The table of effective rules shows all rules that apply to the account — the platform's, which you cannot edit, and yours — each as a sentence with the raw selectors beneath it. When several rules match one action, the strictest one decides.

The document also holds your detectors, in a detectors: section next to layers. Your own data writes it for you; edit it by hand for what the editor does not show, such as words that rule a match out (exclude) or the confidence a find gets (score). Every detector has a kind — pattern, terms, or remote for a service of your own (see Your own detection service) — an id and a title. It reports its finds as a class (corporate, pii or secret) and a subtype, the name rules use for them; a remote detector gives a pair for each entity type under entities. A rule selects what a detector finds by both its finding_class and its finding_subtype: a rule that names only the subtype also makes every built-in detector run wherever the rule applies.

schema_version: 1
detectors:
  - kind: pattern
    id: contract-number
    title: Contract number
    class: corporate
    subtype: CONTRACT_NUMBER
    patterns: ['\bCN-\d{6}\b']
    examples:
      match: ["Please review contract CN-123456 before Friday"]
      no_match: ["Order CN-1234567 has shipped"]
layers:
  - name: organization
    rules:
      - id: org-contract-number-mask
        match:
          action_kind: [llm_request]
          finding_class: [corporate]
          finding_subtype: [CONTRACT_NUMBER]
          destination_trust: [platform, tenant, unknown]
        action: mask
        reason: "Contract numbers are masked before any model"

Patterns are regular expressions of the RE2 kind: no lookahead, lookbehind or backreferences, and \b, \w, \d and \s know ASCII only, so next to Cyrillic letters write classes such as \p{Cyrillic}, \p{L} or \p{N}. The examples are checked every time the rules are saved: each match text must be found and no no_match text may be, so a change that breaks a detector is refused instead of applied. A document holds up to 20 detectors, at most 3 of them services of your own, and up to 2,000,000 characters in all, which only long word lists come near: the page says so and does not let you save a larger one.

Your own data

The guard recognises secrets and personal data on its own. It cannot know that CN-2024-0042 is one of your contract numbers, or that Project Falcon must stay inside the company. Your own data, a card on the Security page right below the box where you describe your rules, is where you teach it: you add a detector, a way of recognising one kind of data, and choose what the guard does with whatever it finds. Only an account owner or admin can add, change or delete detectors. They apply to the agents of your account the way your rules do (see Modes).

Add detector opens an editor with three ways to say what to look for:

  • By examples. Type a few examples of the data in Examples, one per line (up to ten) and, if you like, similar-looking text that must not be found in Must not be found (optional). Suggest a pattern asks a model for a pattern, a description of the data's shape, that finds your examples and leaves the lookalikes alone; the model reads the detector's Name too, so give it one first. The platform checks the answer against every example before showing it, and says which one a pattern misses. Because a model reads what you type, use made-up examples where the real ones are sensitive. Under For advanced users you can edit the pattern or write your own, add context words that make a find more certain when they stand nearby (contract, say), and require a checksum for numbers that carry one: card numbers, INN, SNILS, OGRN and IBAN.
  • As a list. Type or paste the words and names to find in Terms, one per line, up to 5000: clients, partners, project code names. Case does not matter, and a term is found only as a whole word; end it with * to accept any ending, so Globex* also finds Globexes. Load from file reads a .txt file with one term per line, or a .csv file with the terms in its first column, and replaces the list.
  • Your service. For data that neither its look nor a list can tell — a client's number is a number like any other until someone looks it up — a service of your own decides. See Checking with your own service.

Every detector has a Name, which the rule cards and the list of decisions call it by. A pattern or a list also has a Kind of data:

  • Company data — what only your organization has: contract and invoice numbers, client lists, project code names. Nothing else on the platform looks for it, so only the rules you choose act on it.
  • Personal data — data about people that the platform's own detectors miss. The platform's rules about personal data apply to it too.
  • Secrets and access keys — a kind of key or token the platform's own detectors miss. The platform's rules about secrets apply to it too.

From the name the page makes the detector's id and the subtype its finds go by in rules: Contract number becomes contract-number and CONTRACT_NUMBER. They show under For advanced users, where a new detector's subtype can still be changed; once the detector is added, neither changes. A service has no single kind: you set it for each entity type the service reports, as described below.

You can also describe the data in words. Write, in the box where you describe your rules, something like Our contract numbers look like CN-2024-0042 and must never reach a model, and Draft rules proposes a detector together with its rules. A draft can propose a pattern or a list, never a service of your own. The detector appears under Your own data, where you can edit it, and it goes with its rules: leave out all the rules of a draft and its detector is left out too.

What happens with what is found

What to do with findings decides which rules the page creates for the detector:

  • Mask before models (the default) — what is found is replaced with a placeholder before a message goes to any model, the platform's own included. In Enforce, your own message shows which parts the model did not get (see What you see when something is masked).
  • Block in tools — a tool call that carries what is found is blocked. The blocked call shows Blocked with the reason Tool calls may not contain anything matching “Contract number” (see What you see when something is blocked).
  • Mask before models and block in tools — both.
  • Only record — nothing is changed or blocked. The check runs in the background, and Decisions shows where something was found (below).

These are ordinary rules, and like all rules they follow the mode: in Observe nothing is masked or blocked, and the list marks what Enforce would have done. They appear under Organization rules with ids such as org-contract-number-mask, org-contract-number-tools and org-contract-number-audit, and their cards name the detector by its name and subtype. You can delete them there or change them in the document.

A detector's card says what happens with what it finds now, going by the rules in place. A detector that no rule uses is allowed, but it changes nothing, and its card warns you: No rule uses it yet, so nothing happens with what it finds. Edit changes a detector; rename it, change what it reports or choose another way to handle its finds, and the rules made for it are replaced to match. Its way of looking — examples, list or service — cannot change; add a new detector instead. Delete asks whether to remove the rules made for the detector as well: Delete with its rules or Delete, keep the rules.

Trying a detector

Test on text, at the bottom of the editor, runs the detector as it stands — saved or not — on a text you paste in, and shows that text with each find marked and named. Use it on a few real-looking cases before you save; nothing is stored. With a service of your own, the text you paste is sent to your service. Try it before saving (above) takes detectors you have not saved yet into account as well. Suggestions, tests, connection checks and dry runs are limited per hour for each account, like drafting, and so are Check under Advanced and the checks the page runs on detector changes you have not saved yet.

Checking with your own service

Choose Your service when your organization has its own way to recognise the data — a lookup in a customer database, a classifier it trained. Your engineers build the service to the contract on Your own detection service; you connect it here:

  1. Type the Service address. On Donkit's hosted platform it has to be a public HTTPS address; a closed / on-prem installation can allow internal ones too.
  2. If the service wants a token, paste it into Token and press Save token. The token is saved for that address — its scheme, host and port, which the page shows next to the button — and the guard sends it there and nowhere else. If you change the address later, save the token again.
  3. Press Check connection. The guard calls the service with a made-up sample text and says how long it took to answer. The entity types the service reports for that text appear under What the service reports.
  4. Leave ticked the entity types the guard should act on and untick the rest. Check the Kind of data and the Subtype of each ticked one: a new type arrives as company data, with a subtype made from its name. A service reports a type only when it finds one, so if the sample text turns up nothing, paste a text of your own into Test on text; the types it reports are added to the table.
  5. Set Response time, ms, how long the guard waits for an answer (from 100 to 30000, 2000 unless you change it), and choose what happens when the service does not answer.

If the service does not answer — no answer within the response time, an error, or an answer the guard cannot use — has two settings:

  • Do not let the request through (the default). In Enforce, a request that needs the service's answer is stopped rather than let through unchecked.
  • Let it through and mark it unchecked. The request goes on, and Decisions marks the entry not checked with the service's name.

The setting matters when a rule that masks, blocks or asks for approval uses the service. While the guard waits for the service, the request waits too, so choose a response time the service can keep. A service whose finds are only recorded never stops anything, whatever you chose: it runs in the background and is marked not checked when it fails.

The guard sends the service only the text it has to check, never who is asking, which agent it is or which organization. It asks only about actions where a rule could use what the service finds — one of yours or, for personal data and secrets, the platform's own. For the rules the page makes, that is model requests with Mask before models, tool calls with Block in tools and both with Only record. It asks in Observe too, since Observe checks what Enforce would. That text leaves the platform, so use a service you trust with it, and protect it with a token.

Saving and tokens

Adding, editing or deleting a detector does not change anything yet. The change waits with the rule changes you have made, and Save as version N on the Organization rules card stores them all as one new version of the document (The rules you have); Discard throws them all away. Before anything is applied, the platform checks the whole document and lists every problem with where it sits — detectors/0/patterns/0 for a pattern it cannot read, detectors/1/endpoint for an address it may not call, detectors/1/credential for a token that is not stored or is saved for another address. A pattern that no longer finds one of its examples, or finds one of the lookalikes, is refused too. The version history and Roll back cover detectors along with the rules.

A token is the one thing that does not wait for the save: it is stored the moment you press Save token. It is encrypted and never shown again — the field is cleared, and the page only says that a token is saved, and for which address. A token saved again for the same address replaces the old one, and a token you replace or delete stops being used within about half a minute. The document names the token — after the detector's id, contract-numbers-token, say — but never contains it. An account can store up to 20 tokens. A token that no detector uses is listed under Your own data with Delete token; while the saved rules use a token it cannot be deleted, so save the rules without its detector first.

A token is bound to the address it was saved for: the guard sends it to the service at that address and to no other, so neither a detector pointed somewhere else nor a Test on text of one takes it along. Changing a service's address therefore means saving its token again: until you do, the editor says which address the saved token is for, and rules with that detector cannot be saved. The token for the new address is saved under a name of its own — contract-numbers-token-2, say — and the detector names it from then on. The old token stays as it was, so the rules in place keep calling the old address with it until you save the rules with the change; Discard leaves them exactly as they were. Once the change is saved, the old token is listed among the tokens no detector uses. Keep it while you may want to roll back: tokens are not part of a version, so Roll back refuses a version whose service names a token you have since deleted or one now saved for another address. A detector's card warns you, too, when the token its service names is missing or saved for another address, since every call to the service fails without it.

What you see in the Decisions list

The Found column of Decisions shows what the detectors found in the action: one mark for each kind of find, with the number of places it was found in — Contract number × 2. Your detectors appear under the names you gave them, the platform's own under what they found, EMAIL for example. A mark that reads not checked: Contract number means that detector did not answer for this action, so what it would have found is unknown; it does not mean that nothing was found. The platform's own detectors can be marked the same way. The Rule column names the rules that acted.

The platform's own checks of an agent's conversations (see Modes) are listed too, under the agent and with no user.

A detector whose finds are only recorded (Only record) runs in the background, after the request has gone on. It never delays or blocks a request, however slow or unavailable its service is, and what it finds is added to the entry a moment after the entry appears. The one exception to "never delays" is an action that asks for your approval: its card waits for these checks before it appears.

Recording is not protection

The request does not wait for such a check, so it can have gone on before the check finishes: choose masking or blocking for anything that must not leave. And if the platform restarts while a check is still running — for an update, say — what it would have found is lost.

Who can approve

An approval confirms what you asked the agent to do, so the card goes to the person whose message the agent is working on, and only they can answer it:

  • You and the members of your organization confirm your own actions, in the chat where the agent asked, and in the Builder while you are building. A member of the organization using its agent gets the card, not the agent's owner.
  • Owners and admins of the organization do not approve for anyone else. Their say over what agents may do is the rules on the Security page: a rule can forbid an action outright or make it ask, and nobody can confirm their way past a rule that forbids.
  • Visitors of a published agent — people outside your organization — cannot take actions with side effects at all while the rule the organization starts with is in place (see Your own rules). Delete that rule, and a visitor confirms such actions themselves, the same way you do.
  • API clients and other agents calling yours have no one to ask: in Enforce mode an action of theirs that would need approval is blocked.
  • Workflow runs have no one to ask either: in Enforce mode a workflow step's action that would need approval — a write through Google Workspace or an MCP server, for example — is blocked. The run stops under Step refused with This step was refused — by a workflow policy or by the service it called. and waits for you. The step's error gives the guard's reason and says that a workflow run can't ask for approval yet: to let the step run, allow the action in your rules on the Security page, or do it yourself outside the workflow. The run does not retry or try to fix itself.

What you see when something is masked

When the guard hides part of a message you wrote before a model reads it — a secret, or personal data that must not reach that model — your message shows which parts the model did not get. Each of them appears partly hidden: at most two characters at each end are left — an••••••om for an email address, for example — and there are always six dots, so even the length is not given away. Click the eye next to a hidden part to see what you wrote there, and click it again to hide it. This only changes what you see: the model did not get that part either way.

Only you can reveal what you wrote. Anyone else who sees your message — another editor of the agent in the Builder chat you share, for example — sees only the hidden form, with no eye to reveal it. A message you send while the Builder is working reaches the other editors a moment later than you, once the guard has checked it. The short preview of a message in a list of chats shows the hidden form to everyone, you included, and so do the examples behind the Builder's statistics.

This works with the agents of your account — in an agent's chat, in a published agent and in the Builder — while the account is in Enforce mode: in Observe nothing is masked, so nothing is marked. Donkit and the built-in agents follow the platform default instead (see Modes). Only text you type in a chat is marked — voice messages, attached files and messages sent to an agent through its API are not, and the mobile apps show your message as you wrote it. A masking rule added later does not mark messages sent before it.

What you see when something is blocked

  • In the chat, a notice explains that the guard blocked the action, that the approval was rejected, or that no decision came in time. The agent's turn ends there.
  • In some cases the agent is told the action was blocked and continues, explaining what it could not do. The blocked tool call shows Blocked with the reason in place of its normal result.
  • In Enforce mode, a check that a masking, blocking or approval rule needs is never skipped: a request the guard could not finish checking for such a rule is not let through. The notice says so and asks you to try again: no rule of yours stopped it, and the same request usually goes through once the check completes. The guard waits for its own checks as long as they take; it gives up only when the checking service stops answering altogether.
  • Checks used only for recording — such as the one that records personal data sent to platform models — run in the background and never hold up or block a request; only an approval card waits for them before it appears. When one of them cannot finish, nothing is stopped, and Decisions marks the entry not checked.
  • A service of your own is one more reason for that notice when it is set to Do not let the request through and does not answer within its response time while a rule that masks, blocks or asks for approval is waiting for it. One set to Let it through and mark it unchecked, or used only to record, stops nothing: the request goes on, and Decisions marks the entry not checked (see Checking with your own service).
  • In a workflow run, when the guard blocks what a step is doing — the action of an Action step, or a request a step sends to a model — the run stops under Step refused and waits for you, and the step's error gives the guard's reason: a rule of yours that forbids it, or an approval the run could not ask for. When the guard could not finish checking it, the step is retried automatically instead, like any temporary failure, and a scheduled workflow keeps its schedule; only if the check still cannot finish after the automatic retries does the run stop, under Retries ran out. The tools an Agent step calls are handled as in the chat: a tool call the guard refuses in a way that ends the turn stops the run under Step refused, and one it blocks without ending the turn, or could not finish checking, is reported to the agent, which carries on.

Mobile apps

The approval card is available in the web app and the Builder. The mobile apps show the request as a plain question for now.

Agent security is off until your account switches it on: the platform default is Off unless your installation sets another one. An account in Observe or Enforce gets everything described on this page, workflow runs included.

What an agent can reach, in any mode

Apart from the guard, and whatever mode you chose, every run of an agent starts from a list of exactly what it may reach, worked out on the platform from who is using the agent and where: files, knowledge collections, memory, database records, connections, models and paired devices. Anything not on the list is out of reach, and every use of a resource is checked against it — including a file, document or collection whose name the agent got from somewhere else.

  • Everyone stays in their own space. A person's files, memory, profile, conversations and database records are theirs on each agent; a run for one person never reaches another person's, and a workflow, an API call or a call from another agent runs as the person it belongs to. See Agent learnings & agent files and Agent database.
  • Shared things are shared on purpose. The agent's learnings and files are read by everyone but written only by the people who curate the agent. A connection you share is yours for everyone who uses the agent, changes included (a shared mailbox and a shared Google account are narrower: people who only use the agent can read through them but not send or write). To keep your account out of their hands, set the connection to Each user connects their own (see Shared vs per-user connections). A knowledge collection reaches visitors only when it is marked Use for everyone. A connection is never chosen for a visitor without their pick, and self-healing never takes a fix from a visitor's run into your workflow.
  • A list belongs to one turn. A turn of a chat, a step of a workflow, a request to the API or a voice session each gets its own list, worked out again at its start. Access you take away — a person's invitation, their place in your organization, a collection you stop sharing — is gone from the next turn, step, request or session, including the messages an agent sends on its own after a background job finishes; a turn already in progress loses its access to code, data and connections within about half a minute, and its reply stops at its next check.
  • Code runs in a sandbox. What an agent runs with the Python tool and its Standard I/O MCP servers cannot reach the platform's storage or another person's files; they work on the person's own files and nothing else.
  • Links are short-lived. A link to a stored file stops working after five minutes to an hour, depending on where it was made (see Opening files).
  • Checks of your agent don't read visitors' files. Evaluations and adversarial tests never see what visitors attached to their conversations.
  • The interface visitors open runs apart from Donkit. When people open the interface you built for the agent — on the agent's or the team's page, or in the mobile apps — it runs on a web address of its own. There it can't use the visitor's Donkit sign-in, it reaches only this agent, and it never reaches the visitor's account, billing, settings, API keys or other agents, nor agrees to anything or joins anything on the visitor's behalf. What a person types or uploads into that interface does reach your code. The Builder's preview is different: only you and the people who can edit the agent open it, so it runs on Donkit's own address with your own sign-in. A call that works in the preview can still be refused for visitors. Built-in agents such as Designer and Analyst are written by Donkit and also run on Donkit's own address.
  • People agree before they start. Everyone who uses an agent someone else built is first shown what its author can see and agrees or leaves (see What visitors agree to).

Self-hosted deployments

Published agent interfaces get web addresses of their own only when the installation has a wildcard address and certificate for them and serves the platform over HTTPS. Otherwise they run in an isolated mode, where what an interface saves on the visitor's device lasts until the page is reloaded. Ask your administrator which applies to your installation.

Security events in your SIEM

A self-hosted installation can send sign-ins, changes of members and roles and API keys to your SIEM — see Sending security events to your SIEM.