TLDR: https://github.com/xarg/pghoard-k8s

‍

This is a small tutorial on how to do incremental backups using pghoard for your PostgreSQL (I assume you’re running everything in Kubernetes). This is intended to help people to get started faster and not waste time finding the right dependencies, etc..

‍

pghoard is a PostgreSQL backup daemon that incrementally backups your files on a object storage (S3, Google Cloud Storage, etc..).
For this tutorial what we’re trying to achieve is to upload our PostgreSQL to S3.

‍

First, let’s create our docker image (we’re using the alpine:3.4 image cause it’s small):

FROM alpine:3.4

ENV REPLICA_USER "replica"
ENV REPLICA_PASSWORD "replica"

RUN apk add --no-cache \
   bash \
   build-base \        
   python3 \
   python3-dev \
   ca-certificates \
   postgresql \
   postgresql-dev \
   libffi-dev \
   snappy-dev
RUN python3 -m ensurepip && \
   rm -r /usr/lib/python*/ensurepip && \
   pip3 install --upgrade pip setuptools && \
   rm -r /root/.cache && \
   pip3 install boto pghoard


COPY pghoard.json /pghoard.json.template
COPY pghoard.sh /

CMD /pghoard.sh

‍

‍

REPLICA_USER and REPLICA_PASSWORD env vars will be replaced later in your Kubernetes conf by whatever your config is in production, I use those values to test locally using docker-compose.

‍

The config pghoard.json which tells where to get your data from and where to upload it and how:

‍

{
   "backup_location": "/data",
   "backup_sites": {
       "default": {
           "active_backup_mode": "pg_receivexlog",
           "basebackup_count": 2,
           "basebackup_interval_hours": 24,
           "nodes": [
               {
                   "host": "YOUR-PG-HOST",
                   "port": 5432,
                   "user": "replica",
                   "password": "replica",
                   "application_name": "pghoard"
               }
           ],
           "object_storage": {
               "aws_access_key_id": "REPLACE",
               "aws_secret_access_key": "REPLACE",
               "bucket_name": "REPLACE",
               "region": "us-east-1",
               "storage_type": "s3"
           },
           "pg_bin_directory": "/usr/bin"
       }
   },
   "http_address": "127.0.0.1",
   "http_port": 16000,
   "log_level": "INFO",
   "syslog": false,
   "syslog_address": "/dev/log",
   "syslog_facility": "local2"
}

‍

Obviously replace the values above with your own. And read pghoard docs for more config explanation.

‍

Note: Make sure you have enough space in your /data; use a Google Persistent Volume if you DB is very big.

‍

Launch script which does 2 things:

1. Replaces our ENV variables with the right username and password for our replication (make sure you have enough connections for your replica user)
2. Launches the pghoard daemon.

‍

‍

#!/usr/bin/env bash

set -e

if [ -n "$TESTING" ]; then
   echo "Not running backup when testing"
   exit 0
fi

cat /pghoard.json.template | sed "s/\"password\": \"replica\"/\"password\": \"${REPLICA_PASSWORD}\"/" | sed "s/\"user\": \"replica\"/\"password\": \"${REPLICA_USER}\"/" > /pghoard.json
pghoard --config /pghoard.json

‍

Once you build and upload your image to gcr.io you’ll need a replication controller to start your pghoard daemon pod:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: pghoard
spec:
 replicas: 1
 selector:
   app: pghoard
 template:
   metadata:
     labels:
       app: pghoard
   spec:
       containers:
       - name: pghoard
         env:
           - name: REPLICA_USER
             value: "replicant"
           - name: REPLICA_PASSWORD
             value: "The tortoise lays on its back, its belly baking in the hot sun, beating its legs trying to turn itself over. But it can't. Not with out your help. But you're not helping."
         image: gcr.io/your-project/pghoard:latest

‍

The reason I use a replication controller is because I want the pod to restart if it fails, if a simple pod is used it will stay dead and you’ll not have backups.

‍

Future to do:

• Monitoring (are you backups actually done? if not, do you receive a notification?)
• Stats collection.
• Encryption of backups locally and then uploaded to the cloud (this is supported by pghoard).

Hope it helps, stay safe and sleep well at night.

‍

Again, repo with the above: https://github.com/xarg/pghoard-k8s

At Gorgias we recently switched our flask & celery apps from Google Cloud VMs provisioned with Fabric to using docker with kubernetes (k8s). This is a post about our experience doing this.

‍

Note: I'm assuming that you're somewhat familiar with Docker.

‍

Docker structure

The killer feature of Docker for us is that it allows us to make layered binary images of our app. What this means is that you can start with a minimal base image, then make a python image on top of that, then an app image on top of the python one, etc..

‍

Here's the hierarchy of our docker images:

• gorgias/base - we're using phusion/baseimage as a starting base image.
• gorgias/pgbouncer
• gorgias/rabbitmq
• gorgias/nginx - extends gorgias/base and installs NGINX
• gorgias/python - Installs pip, python3.5 - yes, using it in production.
• gorgias/app - This installs all the system dependencies: libpq, libxml, etc.. and then does pip install -r requirements.txt
• gorgias/web - this sets up uWSGI and runs our flask app
• gorgias/worker - Celery worker

‍

Piece of advice: If you used to run your app using supervisord before I would advise to avoid the temptation to do the same with docker, just let your container crash and let k8s handle it.

‍

Now we can run the above images using: docker-compose, docker-swarm, k8s, Mesos, etc...

‍

We chose Kubernetes too

There is an excellent post about the differences between container deployments which also settles for k8s.

‍

I'll also just assume that you already did your homework and you plan to use k8s. But just to put more data out there:

‍

Main reason: We are using Google Cloud already and it provides a ready to use Kubernetes cluster on their cloud.

‍

This is huge as we don't have to manage the k8s cluster and can focus on deploying our apps to production instead.

‍

Let's begin by making a list of what we need to run our app in production:

• Database (Postgres)
• Message queue (RabbitMQ)
• App servers (uWSGI running Flask)
• Web servers (NGINX proxies uWSGI and serves static files)
• Workers (celery)

‍

Why Kubernetes again?

We ran the above in a normal VM environment, why would we need k8s? To understand this, let's dig a bit into what k8s offers:

• A pod is a group of containers (docker, rtk, lxc...) that runs on a Node. It's a group because sometimes you want to run a few containers next to each other. For example we are running uWSGI and NGINX on the same pod (on the same VM and they share the same ip, ports, etc..).
• A Node is a machine (VM or metal) that runs a k8s daemon (minion) that runs the Pods.
• The nodes are managed by the k8s master (which in our case is managed by the container engine from Google).
• Replication Controller or for short rc tells k8s how many pods of a certain type to run. Note that you don't tell k8s where to run them, it's master's job to schedule them. They are also used to do rolling updates, and autoscaling. Pure awesome.
• Services take the exposed ports of your Pods and publishes them (usually to the Public). Now what's cool about a service that it can load-balance the connections to your pods, so you don't need to manage your HAProxy or NGINX. It uses labels to figure out what pods to include in it's pool.
• Labels: The CSS selectors of k8s - use them everywhere!
• ‍

There are more concepts like volumes, claims, secrets, but let's not worry about them for now.

‍

Postgres

We're using Postgres as our main storage and we are not running it using Kubernetes.

‍

Now we are running postgres in k8s (1 hot standby + pghoard), you can ignore the rest of this paragaph.

The reason here is that we wanted to run Postgres using provisioned SSD + high memory instances. We could have created a cluster just for postgres with these types of machines, but it seemed like an overkill.

The philosophy of k8s is that you should design your cluster with the thought that pods/nodes of your cluster are just gonna die randomly. I haven't figured our how to setup Postgres with this constraint in mind. So we're just running it replicated with a hot-standby and doing backups with wall-e for now. If you want to try it with k8s there is a guide here. And make sure you tell us about it.

‍

RabbitMQ

RabbitMQ (used as message broker for Celery) is running on k8s as it's easier (than Postgres) to make a cluster. Not gonna dive into the details. It's using a replication controller to run 3 pods containing rabbitmq instances. This guide helped: https://www.rabbitmq.com/clustering.html

‍

uWSGI & NGINX

As I mentioned before, we're using a replication controller to run 3 pods, each containing uWSGI & NGINX containers duo: gorgias/web & gorgias/nginx. Here's our replication controller web-rc.yaml config:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: web
spec:
 replicas: 3 # how many copies of the template below we need to run
 selector:
   app: web
 template:
   metadata:
     labels:
       app: web
   spec:
     containers:
     - name: web
       image: gcr.io/your-project/web:latest # the image that you pushed to Google Container Registry using gcloud docker push
       ports: # these are the exposed ports of your Pods that are later used by the k8s Service
         - containerPort: 3033
           name: "uwsgi"
         - containerPort: 9099
           name: "stats"
     - name: nginx
       image: gcr.io/your-project/nginx:latest
       ports:
         - containerPort: 8000
           name: "http"
         - containerPort: 4430
           name: "https"
       volumeMounts: # this holds our SSL keys to be used with nginx. I haven't found a way to use the http load balancer of google with k8s.  
         - name: "secrets"
           mountPath: "/path/to/secrets"
           readOnly: true
     volumes:
       - name: "secrets"
         secret:
           secretName: "ssl-secret"
And now the web-service.yaml:apiVersion: v1
kind: Service
metadata:
 name: web
spec:
 ports:
 - port: 80
   targetPort: 8000
   name: "http"
   protocol: TCP
 - port: 443
   targetPort: 4430
   name: "https"
   protocol: TCP
 selector:
   app: web
 type: LoadBalancer

‍

That type: LoadBalancer at the end is super important because it tells k8s to request a public IP and route the network to the Pods with the selector=app:web.
If you're doing a rolling-update or just restarting your pods, you don't have to change the service. It will look for pods matching those labels.

‍

Celery

Also a replication controller that runs 4 pods containing a single container: gorgias/worker, but doesn't need a service as it only consumes stuff. Here's our worker-rc.yaml:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: worker
spec:
 replicas: 2
 selector:
   app: worker
 template:
   metadata:
     labels:
       app: worker
   spec:
     containers:
     - name: worker
       image: gcr.io/your-project/worker:latest

‍

‍

Some tips

• Installing some python deps take a long time, for stuff like numpy, scipy, etc.. try to install them in your namespace/app container using pip and then do another pip install in the container that extends it, ex: namespace/web, this way you don't have to rebuild all the deps every time you update one package or just update your app.
• Spend some time playing with gcloud and kubectl. This will be the fastest way to learn of google cloud and k8s.
• Base image choice is important. I tried phusion/baseimage and ubuntu/core. Settled for phusion/baseimage because it seems to handle the init part better than ubuntu core. They still feel too heavy. phusion/baseimage is 188MB.

‍

‍

Conclusion

With Kubernetes, docker finally started to make sense to me. It's great because it provides great tools out of the box for doing web app deployment. Replication controllers, Services (with LoadBalancer included), Persistent Volumes, internal DNS. It should have all you need to make a resilient web app fast.

At Gorgias we're building a next generation helpdesk that allows responding 2x faster to common customer requests and having a fast and reliable infrastructure is crucial to achieve our goals.

If you're interested in working with this kind of stuff (especially to improve it): we're hiring!

We've released a new version of the Chrome Extension, with sharing features and a new navigation bar. We hope you'll love it!

‍

Share templates inside the extension

Before, the only way to share templates with your teammates was to login on Gorgias.io.

If you're on the startup plan, when you create a template, you can choose who has access to it: either only you, specific people, or your entire team.

‍

‍

The account management section is now available in the extension, under settings.

‍

New navigation

Tags are now available on the left. It's easier to manage hundreds of templates with them.
You can also navigate through your private & shared templates. Shared templates include templates shared with specific people or with everyone.

‍

‍

We hope you'll enjoy this new version of our Chrome Extension. As usual, your feedback & questions are welcome!

Today, we’re thrilled to announce that we’ve raised a $1.5 million Seed round led by Charles River Ventures and Amplify Partners, to help build our new helpdesk.

‍

We’re incredibly grateful to early users, customers, mentors we’ve met both at and Techstars.

‍

We started the journey with Alex at the beginning of 2015 with our Chrome extension, which helps write email faster using templates. We’ve been pleased all along with customers telling us about how helpful it was, especially for customer support.

‍

While building the extension, we’ve realized that a big inefficiency in support lies in the lack of integration between the helpdesk, the payment system, CRM and other tools support is using. As a result, agents need to do a lot of repetitive work to respond to customer requests, especially when the company is big.

‍

That’s why we’ve decided to build a new kind of helpdesk to enable customer support agents to respond 2x faster to customers. You can find out more and sign up for our private beta here.

‍

When a company has a lot of customers, support becomes repetitive. We want to provide support teams with tools to automate the way they treat simple repetitive requests. This way, they have more time for complex customer issues.

‍

We'll now focus on this helpdesk and on growing the team, oh, and if you'd like to join, we're hiring! We're super excited about this new helpdesk product. If you’re using the extension, don’t worry.

‍

Romain & Alex

We've been busy, but not deaf!

Last few months we got lots of feedback about our extension and found to our delight that most people are satisfied, but still a few recurrent issues came up:

• The HTML/WYSIWYG editor sucks.
• No support for Outlook.com.

‍

We listened and now we're presenting:

• A brand new editor
• Support for outlook.com
• More on the Rich-Text editor

‍

WYSIWYG editors for the web are notoriously buggy and are just difficult to develop.

‍

I have yet to see one that is bug free. There are few venerable editors that do a good job like TinyMCE, FKEditor or CKEditor.. but they are big and all have edge cases that break the intended formatting and add a lot of garbage html.

‍

There are newer good quality editors in town such as Redactor. The one that got my attention and finally landed in Gorgias is this wonderful editor called which is super lightweight, uses modern content-editable (no i-frames) and 'just works' most of the time. That's not to say it's perfect, but it's good enough and I'm satisfied with it's direction in terms of development.

‍

Enjoy it and as always send us bug-reports or feedback on: support@gorgias.com

TL;DR:

• You don’t need to rebuild your Help Center to make it work with AI—you just need to structure it smarter.
• AI Agent reads your content in three layers: Help Center, Guidance, and Actions, following an “if / when / then” logic to find and share accurate answers.
• Most AI escalations happen because Help Docs are vague or incomplete. Start by improving your top 10 ticket topics—like order status, returns, and refunds.
• Make your articles scannable, define clear conditions, link next steps, and keep your tone consistent. These small tweaks help AI Agent resolve more tickets on its own—and free up your team to focus on what matters most.

As holiday season support volumes spike and teams lean on AI to keep up, one frustration keeps surfacing, our Help Center has the answers—so why can’t AI find them?

The truth is, AI can’t help customers if it can’t understand your Help Center. Most large language models (LLMs), including Gorgias AI Agent, don’t ignore your existing docs, they just struggle to find clear, structured answers inside them.

The good news is you don’t need to rebuild your Help Center or overhaul your content. You simply need to format it in a way that’s easy for both people and AI to read.

We’ll break down how AI Agent reads your Help Center, finds answers, and why small formatting changes can help it respond faster and more accurately, so your team spends less time on escalations.

{{lead-magnet-1}}

How AI Agent uses your Help Center content

Before you start rewriting your Help Center, it helps to understand how AI Agent actually reads and uses it.

Think of it like a three-step process that mirrors how a trained support rep thinks through a ticket.

1. Read Help Center docs

Your Help Center is AI Agent’s brain. AI Agent uses your Help Center to pull facts, policies, and instructions it needs to respond to customers accurately. If your articles are clearly structured and easy to scan, AI Agent can find what it needs fast. If not, it hesitates or escalates.

2. Follow Guidance instructions

Think of Guidance as AI Agent’s decision layer. What should AI Agent do when someone asks for a refund? What about when they ask for a discount? Guidance helps AI Agent provide accurate answers or hand over to a human by following an “if/when/then” framework.

3. Respond and perform

Finally, AI Agent uses a combination of your help docs and Guidance to respond to customers, and if enabled, perform an Action on their behalf—whether that’s changing a shipping address or canceling an order altogether.

Here’s what that looks like in practice:

This structure removes guesswork for both your AI and your customers. The clearer your docs are about when something applies and what happens next, the more accurate and human your automated responses will feel.

A Help Center written for both people and AI Agent:

• Saves your team time
• Reduces escalations
• Helps every customer get the right answer the first time

What causes AI Agent to escalate tickets, and how to fix it

Our data shows that most AI escalations happen for a simple reason––your Help Center doesn’t clearly answer the question your customer is asking.

That’s not a failure of AI. It’s a content issue. When articles are vague, outdated, or missing key details, AI Agent can’t confidently respond, so it passes the ticket to a human.

Here are the top 10 topics that trigger escalations most often:

Each of these topics needs a dedicated, clearly structured Help Doc that uses keywords customers are likely to search and spells out specific conditions. 

Here’s how to strengthen each one:

• Order status: Include expected delivery timelines, tracking link FAQs, and a clear section for “what to do if tracking isn’t updating.”
• Return request: Spell out eligibility requirements, time limits, and how to print or request a return label.
• Order cancellation: Define cut-off times for canceling and link to your “returns” doc for shipped orders.
• Product quality issues: Explain what qualifies as a defect, how to submit photos, and whether replacements or refunds apply.
• Missing item: Clarify how to report missing items and what verification steps your team takes before reshipping.
• Subscription cancellation: Add “if/then” logic for different cases: if paused vs. canceled, if prepaid vs. monthly.
• Order refund: Outline refund timelines, where customers can see status updates, and any exceptions (e.g., partial refunds).
• Product details: Cover sizing, materials, compatibility, or FAQs that drive most product-related questions.
• Return status: State how long returns take to process and where to check progress once a label is scanned.
• Order delivered but not received: Provide step-by-step guidance for checking with neighbors, filing claims, or requesting replacements.

Start by improving these 10 articles first. Together, they account for nearly half of all AI Agent escalations. The clearer your Help Center is on these topics, the fewer tickets your team will ever see, and the faster your AI will resolve the rest.

How to format your Help Center docs for LLMs

Once you know how AI Agent reads your content, the next step is formatting your help docs so it can easily understand and use them. 

The goal isn’t to rewrite everything, it’s to make your articles more structured, scannable, and logic-friendly. 

Here’s how.

1. Use structured, scannable sections

Both humans and large language models read hierarchically. If your article runs together in one long block of text, key answers get buried.

Break articles into clear sections and subheadings (H2s, H3s) for each scenario or condition. Use short paragraphs, bullets, and numbered lists to keep things readable.

Example:

How to Track Your Order

• Step 1: Find your tracking number in your confirmation email.
• Step 2: Click the tracking link to see your delivery status.
• Step 3: If tracking hasn’t updated in 3 days, contact support.

A structured layout helps both AI and shoppers find the right step faster, without confusion or escalation.

2. Write for “if/when/then” logic

AI Agent learns best when your Help Docs clearly define what happens under specific conditions. Think of it like writing directions for a flowchart.

Example:

• “If your order hasn’t arrived within 10 days, contact support for a replacement.”
• “If your order has shipped, you can find the tracking link in your order confirmation email.”

This logic helps AI know what to do and how to explain the answer clearly to the customer.

3. Clarify similar terms and synonyms

Customers don’t always use the same words you do, and neither do LLMs. If your docs treat “cancel,” “stop,” and “pause” as interchangeable, AI Agent might return the wrong answer.

Define each term clearly in your Help Center and add small keyword variations (“cancel subscription,” “end plan,” “pause delivery”) so the AI can recognize related requests.

4. Link to next steps

AI Agent follows links just like a human agent. If your doc ends abruptly, it can’t guide the customer any further.

Always finish articles with an explicit next step, like linking to:

• A form
• Another article
• A support action page

Example: “If your return meets our policy, request your return label here.”

That extra step keeps the conversation moving and prevents unnecessary escalations.

5. Keep tone consistent

AI tools prioritize structure and wording when learning from your Help Center—not emotional tone. 

Phrases like “Don’t worry!” or “We’ve got you!” add noise without clarity.

Instead, use simple, action-driven sentences that tell the customer exactly what to do:

• “Click here to request a refund.”
• “Fill out the warranty form to get a replacement.”

A consistent tone keeps your Help Center professional, helps AI deliver reliable responses, and creates a smoother experience for customers.

LLM-friendly Help Centers in action

You don’t need hundreds of articles or complex workflows to make your Help Center AI-ready. But you do need clarity, structure, and consistency. These Gorgias customers show how it’s done.

Little Words Project: Simple formatting that boosts instant answers

Little Words Project keeps things refreshingly straightforward. Their Help Center uses short paragraphs, descriptive headers, and tightly scoped articles that focus on a single intent, like returns, shipping, or product care. 

That makes it easy for AI Agent to scan the page, pull out the right facts, and return accurate answers on the first try.

Their tone stays friendly and on-brand, but the structure is what shines. Every article flows from question → answer → next step. It’s a minimalist approach, and it works. Both for customers and the AI reading alongside them.

Dr. Bronner’s: Making tools work for the team

Customer education is at the heart of Dr. Bronner’s mission. Their customers often ask detailed questions about product ingredients, packaging, and certifications. With Gorgias, Emily and her team were able to build a robust Help Center that helped to proactively give this information.

The Help Center doesn't just provide information. The integration of interactive Flows, Order Management, and a Contact Form automation allowed Dr. Bronner’s to handle routine inquiries—such as order statuses—quickly and efficiently. These kinds of interactive elements are all possible out-of-the-box, no IT support needed.

Read more: How Dr. Bronner's saved $100k/year by switching from Salesforce, then automated 50% of interactions with Gorgias 

Ekster: Building efficiency through automation and clarity

When Ekster switched to Gorgias, the team wanted to make their Help Center work smarter. By writing clear, structured articles for common questions like order tracking, returns, and product details, they gave both customers and AI Agent the information needed to resolve issues instantly.

"Our previous Help Center solution was the worst. I hated it. Then I saw Gorgias’s Help Center features, and how the Article Recommendations could answer shoppers’ questions instantly, and I loved it. I thought: this is just what we need." —Shauna Cleary, Head of Ecommerce at Ekster

The results followed fast. With well-organized Help Center content and automation built around it, Ekster was able to scale support without expanding the team.

“With all the automations we’ve set up in Gorgias, and because our team in Buenos Aires has ramped up, we didn’t have to rehire any extra agents.” —Shauna Cleary, Head of Ecommerce at Ekster

Learn more: How Ekster used automation to cover the workload of 4 agents 

Rowan: Clean structure that keeps customers (and AI) on track

Rowan’s Help Center is a great example of how clear structure can do the heavy lifting. Their FAQs are grouped into simple categories like piercing, shipping, returns, and aftercare, so readers and AI Agent can jump straight to the right topic without digging. 

For LLMs, that kind of consistency reduces guesswork. For customers, it creates a smooth, reassuring self-service experience. 

TUSHY: Balancing brand voice with automation

TUSHY proves you can maintain personality and structure. Their Help Center articles use clear headings, direct language, and brand-consistent tone. It makes it easy for AI Agent to give accurate, on-brand responses.

“Too often, a great interaction is diminished when a customer feels reduced to just another transaction. With AI, we let the tech handle the selling, unabashedly, if needed, so our future customers can ask anything, even the questions they might be too shy to bring up with a human. In the end, everybody wins!" —Ren Fuller-Wasserman, Senior Director of Customer Experience at TUSHY

Quick checklist to audit your Help Center for AI

Ready to put your Help Center to the test? Use this five-point checklist to make sure your content is easy for both customers and AI to navigate.

1. Are your articles scannable with clear headings?

Break up long text blocks and use descriptive headers (H2s, H3s) so readers and AI Agent can instantly find the right section.

2. Do you define conditions with “if/when/then” phrasing?

Spell out what happens in each scenario. This logic helps AI Agent decide the right next step without second-guessing.

3. Do you cover your top escalation topics?

Make sure your Help Center includes complete, structured articles for high-volume issues like order status, returns, and refunds.

4. Does each article end with a clear next step or link?

Close every piece with a call to action, like a form, related article, or support link, so neither AI nor customers hit a dead end.

5. Is your language simple, action-based, and consistent?

Use direct, predictable phrasing. Avoid filler like “Don’t worry!” and focus on steps customers can actually take.

By tweaking structure instead of your content, it’s easier to turn your Help Center into a self-service powerhouse for both customers and your AI Agent.

Make your Help Center work smarter

Your Help Center already holds the answers your customers need. Now it’s time to make sure AI can find them. A few small tweaks to structure and phrasing can turn your existing content into a powerful, AI-ready knowledge base.

If you’re not sure where to start, review your Help Center with your Gorgias rep or CX team. They can help you identify quick wins and show you how AI Agent pulls information from your articles.

Remember: AI Agent gets smarter with every structured doc you publish.

Ready to optimize your Help Center for faster, more accurate support? Book a demo today.

{{lead-magnet-2}}

TL;DR:

• Suggestion turns browsing into buying by gently guiding action instead of forcing it.
• Fewer, clearer choices reduce decision fatigue and help shoppers move forward with confidence.
• A well-timed prompt with a friendly tone can make automation feel like a real conversation.
• Good design earns trust by being subtle, approachable, and easy to engage with.
• Small, thoughtful cues create moments of connection that make shoppers feel understood.

Shopping today isn’t a linear funnel. It’s a fluid conversation. Browse → question → help → buy → return → repeat.

Every step is a dialogue between the shopper’s intent and the brand’s response. 

But what bridges the gap between “just looking” and “I’m buying” isn’t persuasion or urgency — it’s suggestion: the subtle design, timing, and language cues that guide action without forcing it.

When done well, suggestion becomes the architecture of trust. It’s also the best way to make AI-powered experiences feel human-first, not tech-first.

This article explores how the power of suggestion — rooted in behavioral psychology and UX design — shapes modern conversational commerce. 

Why suggestion matters in the age of conversational commerce

The average ecommerce shopper faces thousands of micro-decisions from the moment they land on a site. Which product? Which variant? Which review to trust? Which shipping method? Each one adds cognitive weight.

Psychologist Barry Schwartz coined the term The Paradox of Choice to describe how abundance often leads to paralysis. In his research, participants faced with too many options were less likely to make a choice and less satisfied when they did.

In ecommerce, that means overload costs conversions. When shoppers must evaluate too many variables, they hesitate, second-guess, or abandon.

Shoppers today expect empathy and ease, not persuasion. When you suggest rather than push, you signal empathy and support.

This is especially important for conversational commerce. Suggestion humanizes automation by making AI interactions feel like conversations rather than transactions.

When you push and persuade, you create a memorable experience for customers — but it’s not the kind you want them to remember.

One Reddit thread perfectly captures the problem: a user tried to cancel their Thrive Market membership and had to ask nine times before the chatbot complied.

Each time, the AI assistant tried to talk them out of it (offering deals, guilt-tripping responses, or irrelevant messages) until the customer’s frustration boiled over.

The thread exploded not just because it was mildly infuriating, but because it illustrated what customers fear most about automation: a lack of empathy.

Suggestion is how you design for trust, ease, and interaction. And for ecommerce and CX professionals, suggestion bridges browsing and buying by prompting dialogue in a gentle, psychologically sound way.

5 ways to use suggestion with agentic AI

The magic of suggestion is that it works with human psychology, not against it. It bridges the space between what a shopper wants to do and what helps them do it.

That’s the foundation of the Fogg Behavior Model, developed by Stanford’s Dr. BJ Fogg. The model states that behavior happens when three things intersect:

1. Motivation — the user wants to do something.
2. Ability — they can do it easily.
3. Prompt — they’re nudged at the right moment.

When these three align, the likelihood of action skyrockets.

In conversational commerce, suggestion is the gentle push that turns intent into interaction.

Below are five ways to apply suggestion with agentic AI (think chat, assistants, and marketing tools) to drive trust, dialogue, and conversion.

1. Build trust with a friendly invitation

A first impression shapes the entire interaction.

A greeting like “Need help?” or “Looking for something special?” signals availability without applying pressure. It’s the digital equivalent of a store associate smiling and saying, “Let me know if you need anything.”

This works because of linguistic framing, which is a form of persuasive language that subtly shapes how people interpret intent.

• Sentences using personal pronouns (“you,” “we”) increase perceived warmth and empathy.
• Questions (vs. imperatives) activate a conversational schema in the brain, inviting a cooperative response.
• Short, low-stakes phrasing signals that engagement is voluntary.

In practice, this means:

• Replace “Start chat now” with “Need a hand finding the right fit?”
• Use punctuation and tone cues that convey friendliness.
• Let the chat invite linger rather than pop up suddenly — this gives users agency.

Take a look at Glamnetic. Its shopping assistant sits at the bottom-right corner of every page. While shoppers scroll on the homepage, a prompt appears: “Shop with AI.” It’s transparent about being an AI chat, but subtle enough to be there for shoppers when they’re ready to use it at their own leisure. 

Gorgias Shopping Assistant is an easy way to do this. At the right moment, Shopping Assistant appears with a greeting such as “Need help?” or “Chat with our AI!” It’s friendly, low-pressure, optional, more “Hey I’m here if you need” than “Buy now!”

2. Make decisions easier by offering fewer choices

If you’ve ever scrolled through 80 product filters and given up, you’ve experienced choice overload. This is the Paradox of Choice in action: 

More options = higher cognitive effort = lower satisfaction.

Suggestion works because it reduces mental effort. When an AI assistant limits quick-reply options to just a few (say, “Long sleeve,” “Short sleeve,” “Sleeveless”), it transforms chaos into clarity.

Each small tap provides forward momentum, a concept known as the goal-gradient effect: the closer we feel to completing a goal, the faster and more positively we act.

How can you apply this to agentic AI? 

• Keep quick replies between 3–5 choices — enough to feel personalized, not overwhelming.
• Present them as progressive steps, not isolated decisions (e.g., “Show me styles” → “Show me colors” → “Add to cart”).
• Always include a “Something else” or “Other” option to preserve user autonomy.
• Refresh options dynamically based on prior selections — a technique known as choice scaffolding.

Gorgias’s Shopping Assistant does this well, surfacing only the most relevant next steps. Instead of forcing open-ended typing, it guides shoppers through mini-decisions that build confidence. Here’s an example from Okanui, showing four clear options to reply to Shopping Assistant.

3. Encourage interaction with a user-friendly design 

Before a shopper reads a single word of text, their brain has already judged whether your interface feels safe to engage with.

That’s the Aesthetic–Usability Effect — when people perceive something as visually appealing, they assume it will be easier and more trustworthy to use.

Design psychologist Don Norman put it best: “Attractive things work better because they make people feel better.”

Here’s why visual subtlety matters:

• Rounded edges and soft shapes signal continuity and friendliness (the human brain associates curves with safety; sharp angles with danger).
• Muted palettes and neutral contrast lower visual stress, allowing the interface to fade into the background until needed.
• Micro-animations — like a gentle glow or slide-in — trigger attention without hijacking focus.
• Minimizable elements give users a sense of control, reducing resistance to engagement.

OSEA’s product description page is a beautiful example of unintrusive design in action. The buttons have rounded edges, the 10% offer isn’t covering other page elements, and the chat sits in the bottom-right corner, making it easily accessible if a shopper has questions about the product.

4. Match your timing to the customer’s pace

Timing is everything in suggestion-based design. Even the most thoughtful interaction will fail if it appears at the wrong moment.

That’s where the Fogg Behavior Model becomes tactical: Behavior = Motivation × Ability × Prompt

When shoppers are motivated (interested in a product) and able (engaging is easy), a well-timed prompt (chat bubble, message, or offer) turns potential into action.

But mistime it, and you risk the opposite. A chat that appears too early feels like spam. Too late, and the user’s interest window closes.

Here’s how to align the timing sweet spot:

• Use behavioral triggers: Fire prompts after meaningful engagement (e.g., 25–30 seconds on a product page, reaching 70% scroll depth, or idling for 15 seconds).
• Match prompt to context: Offer size guidance on apparel pages, warranty info near checkout, or live help on return pages.
• Respect frequency: One well-placed nudge beats five redundant ones.
• Localize timing: Adjust based on device and location. Mobile users often need faster cues due to shorter browsing sessions.

Gorgias Shopping Assistant does all of the above. Using context — such as the current page, conversational context, and cart behavior — helps the AI trigger prompts like “Need help choosing a size?” or “Have questions about shipping?”

5. Aim to educate, reassure, or inspire — not just sell

Every small suggestion — a phrase, a button shape, a pause, a tone — creates what behavioral economists call a moment of micro-trust.

Individually, these moments may feel insignificant. But together, they turn a static interface into a relationship.

When greeting, choices, design, and timing align, conversation becomes the natural outcome — not the goal. That’s what conversational commerce gets right: it reframes success from “did they convert?” to “did they connect?”

For CX teams, this shift requires designing for the emotional continuity of the experience:

• Did each prompt respect the shopper’s autonomy?
• Did the interaction feel like a two-way exchange?
• Did the system adapt to intent rather than dictate it?

We love this example from Perry Ellis to drive this tip home:

Designing for trust in an age of AI

As AI continues to shape how people shop, brands face a choice: Design for control, or design for trust.

Suggestion is the path to the latter.

The right cue, delivered at the right time, reminds people that even in automated spaces, there’s still room for empathy and understanding.

Gorgias was built on the belief that great commerce starts with conversation, not conversion.

{{lead-magnet-2}}

TL;DR:

• AI Agent is getting more accurate every month: It’s improved 14.9% this year thanks to better LLMs, constant updates, and user feedback.
• It writes more correctly than most humans: With a 4.77/5 language score, it’s nailing grammar, tone, and clarity better than human agents.
• It’s empathetic, too: AI Agent now shows more empathy and listens better than human agents.
• Brands are gaining confidence fast: Quality scores jumped from 57% to 85% in just a few months, and CX teams are noticing.
• Customers are almost as happy with AI as with humans: AI Agent’s CSAT is just 0.6 points shy of human agents’ average CSAT.

Handing trust over to AI can be intimidating. One off-brand reply and you undo the reputation and customer loyalty you’ve worked so hard to build. 

That’s why we’ve made accuracy our top priority with Gorgias AI Agent.

For the past year, the Gorgias team has been hard at work fulfilling the pressing  demand for accuracy and speed. AI Agent is getting smarter, faster, and more reliable, and merchants and their customers are happier with the output. 

Here’s the data.

{{lead-magnet-1}}

AI Agent delivers more accurate answers than ever

This year, AI Agent’s accuracy rose from 3.55 to 4.08 out of 5, a 14.9% improvement from January. This average score is based on CX agents' ratings of AI Agent responses in the product, on a scale of 1 to 5.

In the past year, we’ve improved knowledge retrieval, added new integrations, expanded reporting features, and asked for more feedback in-product.

We saw the steadiest leap in July, right after the release of GPT-5. AI Agent began reaching levels of consistency and accuracy that agents could trust.

AI Agent writes with more linguistic precision than humans

Clear, easy-to-understand language helps people trust what they’re reading. Website Planet found that 85% more visitors bounced from a page when typos were present. That’s why we’ve made it a priority for AI Agent to respond to customers with correct grammar, syntax, and tone of voice. 

The efforts have paid off: AI Agent scores a high 4.77 out of 5 in language proficiency compared to 4.4 for human agents. The result is error-free messages that are easy to read and consistent with your brand vocabulary.

AI Agent shows that empathy can be scaled

Accuracy isn’t just about saying the right thing; it’s also about how a message lands. For that reason, we track AI Agent’s communication quality. Did it reply with empathy? Did it exhibit active listening and respond with clear phrasing?

Recently, AI Agent is even scoring slightly above humans with 4.48 out of 5 in communication, compared to 4.27. This means AI Agent captures the nuance of every message by considering the background context and acknowledging customer frustration before it gives customers a solution. 

AI Agent resolves every part of a customer’s question

What happens when a ticket ends without a clear answer? Customers feel neglected and leave the chat still unsure. This can make your brand look out of touch, leaving customers with the lingering feeling that you don’t care.

But don’t worry, we built AI Agent to close that loop every time: AI Agent’s resolution completeness score sits at a perfect 1 out of 1, compared to 0.99 out of 1 for human agents. 

In practice, this means customers feel cared for and understood, while your team receives fewer follow-ups, giving them more time to focus on strategic, high-priority tasks.

Read more: A guide to resolution time: How to measure and lower it

Brand confidence is on the rise

Building a great product is a two-way conversation between our engineers and the people who use it. We listen, review feedback, ship changes, and measure what improves.

From January to November 2025, AI Agent quality rose from about 57% to 85%. August was the first big step up, and September kept climbing. Brands are seeing fewer low-quality or incorrect answers and more steady decisions.

This is proof that merchants and their shoppers are witnessing the improvements we’ve been making, for the better.

Related: The engineering work that keeps Gorgias running smoothly

Shoppers are rating AI support almost as high as human support

At the end of the day, what matters is how customers feel when they talk to support. Do they trust the answer? Do they find it helpful? Are they running into more friction with AI than without it?

Our data shows that customers are appreciating AI assistance more and more. Since the start of 2025, AI Agent on live chat has gotten a CSAT score 40% closer to the average CSAT of human agents. For email, the gap has narrowed by about 8%.

The goal is to eventually achieve a gap of zero. At this point, AI’s support quality is indistinguishable from that of humans. To get there, we’re focusing on practical improvements like accuracy, clear language, complete answers, and better handoff rules.

How we measure CSAT gap: The CSAT gap is calculated by subtracting AI CSAT from human CSAT. When the number is closer to zero, AI is catching up. When it’s negative, AI is still below human results.

Reliable AI interactions start with accuracy

Behind every accurate AI reply is a team that cares about the details. AI Agent doesn’t make up answers—it follows what you teach it. The more effort your team puts into maintaining an up-to-date Help Center and Guidance, the better the customer experience becomes.

As we look ahead to 2026, we’re focused on fine-tuning knowledge retrieval logic, refining Guidance rules, and continuously learning from feedback from you and your customers.

We’re proud of the strides AI Agent continues to make, and can’t wait for more brands to experience the accuracy for themselves.

Want to see how AI Agent delivers exceptional accuracy without sacrificing speed? Book a demo or start a trial today.

{{lead-magnet-2}}