ARCY AI
Security

How AI request content is handled

What is checked before a model reads it, what reaches one, what the assistant does on a page, the fields it never touches, what leaves for the destination you connect.

An end user's chat message is checked first, then answered, then stored only if you let it be. What the assistant does on their page while it answers has its own rules, and a short list of fields it never touches. Each step has its own answer on a questionnaire.

Checked before a model reads it

Every message an end user sends in the chat passes an Amazon Bedrock guardrail in the EU before any AI model reads it. A message carrying payment or secret data is refused with a short line, in the end user's language, asking for it again without them: it never reaches a model, it is not stored in the conversation, and it counts for nothing. A message the other filters flag is answered as a Guarded turn: for that message the assistant cannot change data, act on the page or start a flow, ARCY absorbs its cost, and the turn is stored like any other, marked Guarded turn on Conversations with the filter that fired. Our server log records that a message was refused or guarded, never its text.

The guardrail flags:

  • Hate, sexual content, violence and misconduct, at high strength.
  • Insults, at medium strength, so a frustrated visitor still gets help while abuse aimed at someone does not.
  • Prompt attacks, meaning attempts to override the assistant's instructions or make it reveal them, at high strength.
  • Payment and secret data: a card number, card security code, card expiry date, PIN, IBAN, password, or AWS access or secret key. A visitor never needs to type these to get help, and these are the ones refused rather than guarded.

It does not block profanity, names, email addresses, phone numbers or postal addresses, because a visitor often needs them to be helped.

If the guardrail service cannot be reached, the message is answered without the check, so an outage on our side never locks your users out of help.

What reaches a model

  • The end user's chat message, once it has passed the check above.
  • What the assistant looks up to answer: your trained content, the flows it may offer, and, for a question about the person, the attributes you passed with identify() or saved from a flow, only those whose AI can read this value switch is on (Attributes).
  • When the assistant reads the page the visitor is on: its headings, its button, link and field labels, and the state a control reports, never a field's value, and inside a closed menu only once the assistant opens it, below. A control is named the way a screen reader names it, so a switch or a checkbox row that takes its name from the text beside it is named by that text, and a switch reports whether it is on or off. That state is the only thing read off a control besides its name. A password, card number, card expiry date, card security code, one-time code or bank account number field is named in that reading as present with no value, so the assistant plans around the form instead of trying it. The page address goes without its query string, where reset tokens, search terms and email addresses often sit. A # part goes only when it is a route such as #/settings, cut before its own query.
  • When the assistant performs one of your endpoints to answer: only the Response fields that endpoint declares, and never a field whose Visible to is Dashboard only or Neither. Each value reaches the model marked as data, never as an instruction. Everything else your API answered stays in the browser: a field you did not declare, an internal id, a cost, another person's detail. The call runs from the visitor's own browser on their own session, so your API's credentials never reach ARCY, and the assistant reaches nothing the visitor could not reach by clicking. Set Visible to to Dashboard only on any field the run needs and the model has no business reading. When the call fails, the HTTP status and the first 300 characters of your API's error message reach the model the same way, marked as data, so the answer names the cause; nothing else from a failed answer does. One field carries about 4,000 characters, so an answer holding a long list of records reaches the model in part: whole records only, never half of one, and the model is told how many records there were and that it is holding some of them, so it can neither answer as though the list were empty nor count from what it has. Set Visible to to Dashboard only on the fields a record does not need and offer a read that answers fewer records, and more of them fit.
  • Once per Product, during its first crawl, up to 40 of the public pages ARCY read from your own site, so one model call can draft the Persona and starter questions. Every value taken from the site reaches the model marked as data, never as an instruction.
  • Once a night, for a question your end users keep asking that the assistant could not answer: the question in their most common wording, the assistant's own note on what was missing, your Persona, and the pages of your trained content that match the question. ARCY uses the answer to add a text source, propose a Persona change or ask your team (Conversations). No other end-user data, no attribute and no conversation transcript is sent, and with Store conversations off no question is stored to send.
  • What the end user answers to a question in the conversation: the choice they tapped, as ARCY drew it, and anything they typed in their own words. Both reach the model marked as data.
  • An image or a document the end user attached, on the message it arrived with only. A document (PDF, DOC, DOCX, XLSX, CSV or TXT, one per message, off until you allow it on Appearance) is read by Amazon Bedrock itself, marked as the end user's data, never an instruction; its file name never leaves the browser. A later message carries one line saying what was attached, and the assistant can read an earlier document's text again inside its 30-day retention. The guardrail above screens the typed message, not the text inside a document.
  • The end user's Lifecycle stage, Stuck, the likely Blocker and the step they are on, computed by ARCY from their own session and the page roles ARCY reads from your Funnel map on Reports, and the top passages of your trained content for their message, fetched before the model starts.

Restrictions never reach the chat model. What you write in the Supervisor block on Persona is held by ARCY's Supervisor, on our server, and checked against every reply before the end user reads it: a card, a choice and a step's words included, on the website and on WhatsApp. An exact value is matched in plain code, whatever its case, spacing or look-alike letters, so no model is involved in catching it. A sentence that might break a Restriction, or promise a refund, discount, price, date or inclusion your content does not state, goes to a small model in the EU that answers only pass or stop; no word it reads can reach the end user, and a check that does not answer in 1.5 seconds counts as stop. A stopped sentence is never shown. The reply is rewritten once, told only the category to avoid, and ends by offering a person if that is stopped too. Every stop is marked on the conversation without the words or the value. These checks never count toward your plan.

No model runs while a flow guides a visitor. A value typed into a flow stays in the browser unless a Request step sends it to your own endpoint, straight from the browser, or Save the answer as an attribute keeps it. A saved answer is an attribute from then on: the assistant can read it while its switch is on. The guardrail above does not run on it. Instead, a saved answer and every identify() value pass a check written in plain code before storage: one that looks like a card number, a bank account number (IBAN) or an API key is refused and never logged, so it can never reach a model. Save only what the assistant needs to know about the person.

What the assistant does on the page itself

Your endpoints come first. When none of them covers what the end user asked for, the assistant works the page they are on: it opens another page of yours, scrolls, follows a link or a tab, and fills a field. It acts only on a page under a verified Domain of your workspace and never navigates to, or calls, anything outside them.

It works out the whole run for the page as it is, and asks once. Every action it can take on the page in front of the end user goes on one card, in the order it will happen, as numbered rows: each press, each field it will fill and what it will type there, and any address it will open. One Yes, do it covers the run. A run that only fills fields asks nothing, because a six-field form would otherwise cost six questions; a run that presses anything which could submit, save, send or pay asks first, on the card in the next section.

A run covers one state of the page. The assistant may only name a control the page reading in front of it showed, so when an action changes the page it reads the page again and puts the next short run on its own card, with its own Yes. A four-step checkout costs the end user two or three taps rather than nine, and every row on every card names a control they can see at that moment. The assistant acts only on elements the page has actually rendered: one that is in the document but not on screen is reported back to the model rather than acted on.

It looks inside a closed menu before it says something is not there. Most menus put their items on the page only when they open, so a reading of the page shows a closed account menu, "more" button or settings drawer as one control marked collapsed and nothing inside it. When the reading lacks what the end user asked for, the assistant may open such a control, read what appeared and close it again, with the cursor on the control while it does. Opening a menu asks nothing, because it changes nothing, and the assistant does it at most five times in one answer. A control it found there goes on the same card as any other, its row naming the menu, as in "press Light theme in the User menu", and one Yes, do it opens the menu and presses it. A menu the end user had open stays open, and nothing seen inside a menu is kept. It never tells the end user your product lacks something it did not see, and never sends them to their device or browser settings unless your content says to: when it cannot find a control, it says so and offers a person. A control that reports it only expands but saves something when pressed would still be opened; that is the one case this does not catch.

It points at a control instead of writing directions to it. When the end user asks where something is, the assistant anchors a short note on the control itself, with Next, Stop and one button that presses it for them, and waits. Nothing is drawn unless they asked: the note ends when they press the control, press Next, or do anything else on the page. When the control is not on the page they are on, the assistant follows the trained path to it and points at each control on the way, at most six, with a real step count on the note. The page dims behind a walk of several notes and stays clickable while it does, so doing anything else ends it; reduced motion turns the dim off. A control the path names that is not there stops the walk and says so.

A run that cannot finish stops rather than carrying on. Where an action fails, where the browser does not answer one, and where the next row is a field that is the end user's own, nothing after that row is done. The assistant says what it did, names what it did not, and reads the page again before it proposes anything else. Not now refuses the whole run and ends it, so the end user never has to work out which of four rows their one tap stopped.

One agreement covers one attempt. An operation the end user agreed to is tried once. If it fails, the assistant says what happened and cannot ask for the same operation with the same values again in that turn, so a failing call can never become a run of identical questions. Correcting a value makes it another operation, which asks again. Not now holds for the rest of the turn the same way.

The assistant never reads and never fills six kinds of field: a password, a card number, a card expiry date, a card security code, a one-time code and a bank account number (IBAN). The list is closed, and a field is recognised three ways, so a payment form that names its fields its own way is still caught: by the autocomplete token the field declares, by the kind of input it is, and by what the field is called in its name, id, placeholder or label, in every language the widget speaks. Nothing turns this off, and a value the end user types into the chat is not a way round it either: those values never pass through ARCY's server.

A run that reaches one of those fields carries that row on its card before the end user agrees to anything, named as theirs to fill, and it stops there. The assistant says which field is theirs and what is left after it, and the cursor and the glow are off the page before they type into it. The conversation carries on from there: it does not end at your checkout or your sign-in page, because the end user comes back and asks again.

While a step acts on the page, three things are drawn on it and nothing else. A cursor with a short label such as "Filling check-in date" that moves to the control it is about, a glow along all four edges of the window in your Appearance theme's accent colour, and a Cancel beside the cursor. All three go the moment the step ends. Only Cancel takes a click, and it ends the run wherever it is in a run of several actions: the cursor and the glow pass every press through to your own page, and none of the three takes the keyboard away from the field being filled. An end user whose browser asks for less movement gets a cursor that appears in place and a glow that does not pulse. A step of a flow you drew yourself draws the same three, so your page looks the same whoever planned the step.

What the end user is asked before an operation runs

An operation that only reads runs while the assistant answers, with nothing to press. One whose endpoint is marked Changes data asks first, as a question in the conversation naming what will happen with the real values the call will carry: the product, the dates, the price. It runs on the end user's Yes, do it and not before. One marked No undo carries the line saying so.

ARCY writes every question, never the model. Its sentence is the endpoint's own name in words, the rows under it are the values the call will send, and the words around them are written by ARCY in the end user's own language. Text on a page, or in an API answer, can make the model attempt an operation; it cannot change how the question describes it. Nothing of the question comes back from the browser either: the reply is the pill pressed.

The question offers Yes, do it and Not now, nothing else, and a second operation asks again. An operation that cannot be undone says so on the question. When the assistant means to take two or more operations that each need a yes, it asks once, listing them, and one Yes, do it covers all of them. The end user's Cancel ends the run wherever it is pressed: a call that has not left is never made, and one that had already left is reported as may have gone through.

After the assistant reads the page, every change asks again. Once it has read the page, or looked inside a menu on it, since the end user's last message, every Changes data operation asks first, including one set to Run without asking. A sentence somebody planted on the page, in a review or a product description, cannot reach a write with nobody in between. The end user's next message clears it, and answers from your own endpoints never start it, so a search followed by a booking still runs as you set it.

The assistant performs an operation only while its address sits under a verified Domain of your workspace, and it never reads or fills a password, card number, card expiry date, card security code, one-time code or bank account number field.

What the assistant asks the end user for

To finish a task the assistant sometimes needs a detail only the end user has. It asks one question at a time, in the conversation: a single choice, several choices, or one typed value such as a name, a date or an email. Choices are tappable, and they can be built from what one of your endpoints answered, with the product's picture and a line such as its price. A choice question can also take the end user's own words, and an optional typed value can be skipped: the assistant then carries on with what it has instead of asking again. Time spent on a question does not count against the working time one answer is allowed.

The assistant does not ask for what ARCY already holds. A question for an attribute you passed, for an answer the end user gave earlier in the same chat, or for a response field an endpoint has just returned is refused before the card is written, and the end user never sees it.

ARCY writes the card's controls and the model writes the question. The heading, the free-text label, the Recommended mark, a date range's two field labels and both buttons are ARCY's own words in the end user's language, in English, Turkish, German and Russian. The question itself, and each choice's name and detail line, are the model's words, because that is how a product name and its price reach the card from your own API's answer. They reach the card as text and never as markup, and a choice's picture is only ever an https address.

A value the assistant cannot use is refused in words, in the browser. Where a typed value has to take a shape, the question says what shape before it is answered, and a value that does not fit is refused on the card with the reason in a sentence naming the field, in the end user's language: a code name that has to start with a letter says so rather than asking again unchanged. The check runs in the browser where it can, so the correction costs no round trip, and the words are ARCY's own. Nothing the end user typed is stored by the refusal; the operation's own Rules are what it reads.

A choice comes back as its position on the card, never as its words. The only text that returns from the browser is what the end user typed themselves, and it reaches the model marked as data, never as an instruction.

What the end user can stop

While the assistant works, the chat shows one list where the answer will land: what it is working on and which step it is on, then each step as done, current or still to come. A step ticks off as it finishes. When the assistant runs one of your Flows for the end user, the list carries the Flow's name, each question reads as itself, and it ticks off the moment the end user answers it. After the answer the list stays folded under it, and the chevron on its header opens it. How long each step took is on Conversations, not in the chat.

The composer stays open the whole time. A line the end user types reaches the assistant's next step, not the one already running, so a wrong detail is corrected without starting the task again. Cmd+Enter, or Ctrl+Enter, sends it at once instead: the run stops where it is and the line becomes their next message.

Stop ends the work, not just the reading. The send control becomes Stop while the assistant answers. While one of your Flows runs inside the answer, the Flow's own Stop is the only one, and it ends the Flow and the answer together. Pressing it stops the model, drops whatever step was waiting on the end user, and the visitor's day counts as one Conversation whether the answer finished or not. The words that had already arrived stay in the conversation, and nothing apologises for a stop the end user chose. The step that was running is marked cancelled in the list, the list's header reads Stopped, and one line under it reads You stopped this., in the end user's language.

An answer that runs out of its working time ends with one Continue control, which carries on from where the assistant stopped rather than starting the task again. ARCY writes the words on it, in the end user's own language.

A page that reloads ends the run. Closing or reloading the page ends that run on your server at once rather than leaving it working for a browser that is gone, and the turn is charged at what it spent. Opening the chat again brings the conversation back from the record ARCY already keeps, with a line saying the run stopped when the page reloaded and one control to pick it up. Pressing it sends ARCY's own sentence, in the end user's language, which points the assistant at the conversation it already has instead of starting over. An operation that changes your data is never resumed on its own: its answer went with the page, so whether it went through is unknown, and the assistant says so and asks the end user to check rather than running it a second time.

What leaves ARCY when the assistant brings a person in

Sometimes the right answer is a person. The assistant brings one in when the end user asks for one, when nothing in your trained content or your endpoints answers, when the same step fails twice, or when what they asked about matches a Send to a person line you wrote on Persona. Those four are the only reasons, and your lines are the only one of them you control.

Nothing leaves ARCY until the end user has agreed. The assistant asks whether to pass the conversation to your team, and the question says the reply comes by email to the address it names. They press to send it or press past it, and a question nobody answers is read as a no. An end user ARCY holds no email address for is asked for one next. ARCY never invents an address: without one, nothing is sent. The short summary the assistant writes of what they wanted and what it tried is not shown in the chat; it goes to your team and stays on the turn's trail on Conversations.

What is sent is the conversation, that summary and how to reply to the end user, and nothing else. The reply address, their name where ARCY holds one, your own id for them where they are signed in, the page they were on and the language they were speaking. No attributes, no endpoint answers, no page reading, and no credential of yours. The summary is the exact text the end user agreed to: it is not rewritten or summarised again on the way out. A Product with Store conversations off has no message text to send, so the summary is the whole ticket.

Where it goes is the destination you connected, on Integrations: Zendesk, Intercom, Freshdesk, HubSpot, Crisp, or one email address of your own. One per environment, so a conversation in Development never reaches your live queue unless you connected one there. This is one of only two places ARCY's own server calls out of itself, the other being a chat test, below. Everything ARCY reads about a visitor is read in their own browser, and every other integration on that page holds nothing of yours. The call carries your credential for that destination and the three things above, and nothing comes back from it into ARCY.

On the email destination, the sender is ARCY and the reply-to is the end user. The mail goes out through Resend, which is already on Sub-processors for our own transactional email and carries the conversation in this one case too; the five helpdesk vendors stay your own providers under your own agreement. Your reply reaches the end user directly rather than returning through ARCY, and ARCY operates no inbound mailbox: nothing can be written back into the conversation by email, and the record is the provider's message id rather than a ticket number.

Your helpdesk credential is held the way your Secret key is. Encrypted at rest with AES-256-GCM, decrypted only on the server and only to open a ticket, and never returned to the dashboard, written to a log or shown again after you type it. Where the helpdesk offers a sign-in, you sign in to it and ARCY stores the token it is given instead of a key of yours; where it does not, ARCY stores the key. Disconnect deletes it. A helpdesk that refuses it is shown on that page as needing attention rather than failing quietly.

A ticket that does not open costs the end user nothing. One attempt is made, never a retry, and it is given ten seconds. If it fails, or if no destination is connected, the conversation ends on ARCY's own sentence telling the end user to contact your team, in their language, with that summary under it, and every reply in the chat carries a copy control, so the end user can take it to your team rather than explaining it all again. The assistant renders no link to a page ARCY has not read, so that sentence never points at an address that does not exist.

The end user is never transferred to a live person inside the chat. There is no queue, no waiting room and no second person typing in the widget.

What ARCY's server calls on your own site during a chat test

A chat test is the one thing that has ARCY's own server call your product. Your coding agent starts it with Battle test the chat and fix what it finds from ARCY MCP, after showing you what the run costs and waiting for your yes. Every run is kept, and your coding agent reads it back.

It calls only your public operations, and only against Development. An operation that changes data, one that needs a signed-in visitor, and one that runs as a function on your own page are never called: ARCY holds no password of yours and cannot sign in as anybody, so each of those is answered instead from an example answer your agent wrote from your code. Your Production site is not called at all.

It calls only an address under a Domain you verified. An address anywhere else is refused before ARCY looks the name up, so no call leaves. The name is then resolved, and an address that resolves inside a private network is refused too, which covers a public name pointed at an internal one. ARCY connects to the address it checked, so a name that answers differently a moment later cannot carry the call somewhere else. Each call is given ten seconds and the answer is read up to 256 KB.

Nothing is written, in any environment. A step that would change something stops at the card it would have shown the end user, and the card is what the run scores: whether the assistant asked for the right operation with the right values. The card is never pressed. No end user exists, so no conversation, event, person or number of yours is written by a run.

What is read is what you declared. From each answer, only the response fields you named on Endpoints, and never a field marked as hidden from AI. The transcript the run keeps shows the names of the values it carried and not the values.

What an AI access switch keeps out

Every attribute except the four ARCY computes carries AI can read this value, on by default. Off, no AI model receives the value on any path: the assistant's lookup of the person leaves it out, a Persona field that mentions it reads blank to the model, and the Person summary on Users skips it. A query over your rows still uses the value; a query is not a model. Attribute names stay visible to the model; only the value is withheld. Your team still reads it in the dashboard, and flow conditions, Request steps, step text and the filters you set by hand keep using it. Keys you never declared, and archived ones, reach no model either.

What Amazon Bedrock and ARCY keep

Amazon Bedrock keeps nothing. Inference runs through Amazon Bedrock, which does not retain request content and does not use it to train foundation models. No request content leaves AWS to reach a separate AI vendor.

ARCY's own call log holds no content. We record what a call cost us in tokens, the Conversation it counted toward, and which model served it. The prompt and the response are not part of that record.

Conversations are stored so you can read them. A conversation between an end user and your assistant is kept for 12 months, so the end user can pick it up again and so you can review it in your dashboard. Every retention period is on Data retention.

An endpoint answer is kept only as the fields you declared. When the assistant performs an endpoint, the trimmed fields above are stored with that conversation, so a later message knows what was found without calling your operation a second time. They are kept as long as the conversation is, and a field the AI cannot see under Visible to is not among them.

Turning conversation storage off

Turn Store conversations off on the Product settings page. With it off, ARCY keeps only usage details for each conversation, the mode, the page and the timing, and never stores the message text, the assistant's reply, or any endpoint field it read.

One record survives that switch: when ARCY cannot answer a question, the fact that it failed, the reason and the time are still recorded, so the count of unanswered questions stays honest. The question text itself is not stored while the switch is off.

Writing it into a questionnaire

Every chat message is screened in the EU for harmful content, prompt attacks and payment or secret data before a model reads it. A message carrying payment or secret data is refused and not stored; a message flagged for anything else is answered with every data change, page action and flow withheld for that message. Payment and credential data is never stored as an attribute by any path, so none of it can reach a model, and every attribute you send has a switch that keeps its value from every AI model. No model runs during a guided flow. An operation the assistant performs runs from the end user's own browser on their own session, and only the response fields the operator declared, less those marked hidden from AI, come back from it, or, when it fails, its HTTP status and the first 300 characters of its error message. An operation that changes data runs only on the end user's yes, given on a card ARCY writes itself from the operation's name and the values the call will carry, so no text a page or an API answer supplies can change what the end user is agreeing to. Where no operation fits, the assistant may fill and press on the page the end user is already on, under a verified domain only, may open a closed menu there to read it and close it again, and it never reads or fills a password, card number, card expiry date, card security code, one-time code or bank account number field, by any path and with no setting that permits it. A detail the assistant needs from the end user is asked on a card whose controls ARCY writes, where a choice is answered by its position, so the only text returning from the browser is what the end user typed, and the assistant never asks for an attribute, an earlier answer or an endpoint field it is already holding. An end user can pause the assistant mid-answer, or stop it, and a stop ends the model call as well and charges only what that answer had already spent. Nothing about a conversation leaves ARCY for a third party unless the end user presses to send it to your team, and what is then sent is the conversation, that summary and how to reply to them, to the one destination you connected yourself and to nowhere else; your credential for it is encrypted at rest, never leaves our server and can be deleted by you at any time. Where that destination is an email address of your own, the mail goes out through Resend with the end user as the reply-to, and ARCY operates no inbound mailbox. The assistant renders no link to a page ARCY has not read. A Restriction you write never reaches the chat model, and every reply is checked against your Restrictions before the end user reads it. Nothing is retained by Amazon Bedrock. What ARCY retains is the transcript you can see in your own dashboard, not a hidden copy of the request, and you can switch that transcript off.

On this page