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:

• Train your AI on your brand voice. A clear voice guide that covers tone, style, and formality helps your AI sound more natural and aligned with your brand.
• Add short delays before AI responds. A one- or two-second pause can make AI responses seem more thoughtful.
• Avoid generic phrases. Swap out formal responses for on-brand language that sounds like a real person on your team.
• Mention customer context in replies. Referencing order history or previous conversations makes AI sound more human and builds trust.
• Balance automation with human support. Let customers know when they are speaking to AI and escalate to a human when needed to avoid frustration.

Your AI sounds like a robot, and your customers can tell.

Sure, the answer is right, but something feels off. The tone of voice is stiff. The phrases are predictable and generic. At most, it sounds copy-pasted. This may not be a big deal from your side of support. In reality, it’s costing you more than you think.

Recent data shows that 45% of U.S. adults find customer service chatbots unfavorable, up from 43% in 2022. As awareness of chatbots has increased, so have negative opinions of them. Only 19% of people say chatbots are helpful or beneficial in addressing their queries. The gap isn't just about capability. It's about trust. When AI sounds impersonal, customers disengage or leave frustrated.

Luckily, you don't need to choose between automation and the human touch. 

In this guide, we'll show you six practical ways to train your AI to sound natural, build trust, and deliver the kind of support your customers actually like.

1. Train your AI on your brand voice

The fastest way to make your AI sound more human is to teach it to sound like you. AI is only as good as the input you give it, so the more detailed your brand voice training, the more natural and on-brand your responses will be.

Start by building a brand voice guide. It doesn't need to be complicated, but it should clearly define how your brand communicates with customers. At minimum, include:

• Tone: Is your brand warm and empathetic? Confident and cheeky? Straightforward and helpful?‍
• Style: How does your brand write? What is your personality? Short or long sentences, contractions or not, punctuation choices, and overall rhythm.‍
• Formality: Do you use slang? Emojis? Address customers as “you,” “y’all,” or something else?‍
• Friendliness: How personable should your AI sound? Is it playful, or should responses stay neutral and professional?

Think of your AI as a character. Samantha Gagliardi, Associate Director of Customer Experience at Rhoback, described their approach as building an AI persona:

"I kind of treat it like breaking down an actor. I used to sing and perform for a living — how would I break down the character of Rhoback? How does Rhoback speak? What age are they? What makes the most sense?" 

Next step

✅ Create a brand voice guide with tone, style, formality, and example phrases.

2. Delay responses to mimic human behavior

Humans associate short pauses with thinking, so when your AI responds too quickly, it instantly feels unnatural.

Adding small delays helps your AI feel more like a real teammate.

Where to add response delays:

• Before sharing info that would realistically take a moment to look up, e.g., order history
• Before confirming an action like issuing a refund or applying a discount
• Transitioning or escalating between steps or agents
• Emotional messages, like customer complaints and product quality issues

Even a one- to two-second pause can make a big difference in a robotic or human-sounding AI.

Next step

✅ Add instructions in your AI’s knowledge base to include short response delays during key moments.

3. Avoid generic phrasing and canned language

Generic phrases make your AI sound like... well, AI. Customers can spot a copy-pasted response immediately — especially when it's overly formal.

That doesn't mean you need to be extremely casual. It means being true to your brand. Whether your voice is professional or conversational, the goal is the same: sound like a real person on your team.

Here's how to replace robotic phrasing with more brand-aligned responses:

Next step

✅ Identify your five most common inquiries and give your AI a rewritten example response for each.

4. Use context to inform answers

One of the biggest tells that a response is AI-generated? It ignores what's already happened.

When your AI doesn't reference order history or past conversations, customers are forced to repeat themselves. Repetition can lead to frustration and can quickly turn a good customer experience into a bad one.

Great AI uses context to craft replies that feel personalized and genuinely helpful.

Here's what good context looks like in AI responses:

• Order awareness: The AI knows the customer placed an order yesterday and provides an accurate delivery estimate without asking for the order number again.
• ‍Conversation continuity: If the customer reached out earlier that week from a different support channel, the AI references that interaction or picks up where things left off.‍
• Customer type: First-time shopper? VIP? The AI adjusts tone and detail level accordingly.

Tools like Gorgias AI Agent automatically pull in customer and order data, so replies feel human and contextual without sacrificing speed.

Next step

✅ Add instructions that prompt your AI to reference order details and/or past conversations in its replies, so customers feel acknowledged.

5. Balance automation with human handoff

Customers just want help. They don't care whether it comes from a human or AI, as long as it's the right help. But if you try to trick them, it backfires fast. AI that pretend to be human often give customers the runaround, especially when the issue is complex or emotional.

A better approach is to be transparent. Solve what you can, and hand off anything else to an agent as needed.

When to disclose that the customer is talking to AI:

• You can disclose it at the start of the conversation, or include a disclaimer in your chat widget, contact page, or help center to let customers know AI may assist
• When the customer asks to speak to a human or expresses frustration
• If the AI cannot fulfill the request and needs to escalate
• Anytime the AI is making decisions, like issuing refunds or processing cancellations
• When transitioning from AI to a human agent

For more on this topic, check out our article: Should You Tell Customers They're Talking to AI?

Next step

✅ Set clear rules for when your AI should escalate to a human and include handoff messaging that sets expectations and preserves context.

6. Add intentional imperfections to sound human

We're giving you permission to break the rules a little bit. The most human-sounding AI doesn't follow perfect grammar or structure. It reflects the messiness of real dialogue.

People don't speak in flawless sentences every time. We pause, rephrase, cut ourselves off, and throw in the occasional emoji or "uh." When AI has an unpredictable cadence, it feels more relatable and, in turn, more human.

What an imperfect AI could look like: 

• Vary sentence length and structure. Some short and choppy, others long. 
• Add subtle grammatical “mistakes” like sentence fragments or informal punctuation. 
• Mix in casual phrasing or idioms where appropriate. 
• Avoid mechanical-sounding transitions. 
• Occasionally use filler phrases like "kinda," "just checking," or "I think."

These imperfections give your AI a more believable voice.

Next step

✅ Add instructions for your AI that permit variation in grammar, tone, and sentence structure to mimic real human speech.

Natural-sounding AI is easier to set up than you think

Human-sounding AI doesn’t require complex prompts or endless fine-tuning. With the right voice guidelines, small tone adjustments, and a few smart instructions, your AI can sound like a real part of your team.

Book a demo of Gorgias AI Agent and see for yourself.

{{lead-magnet-2}}

TL;DR:

• If your AI is giving wrong answers or getting stuck, it’s likely due to missing or conflicting knowledge. Ensure your AI is trained with up-to-date documents and add guardrails to prevent off-topic replies.
• Loops and escalations usually mean your escalation rules aren’t specific enough. Define when AI should step in, when it should hand over, and create “escape phrases” that trigger human takeover.
• Customers still want human help. Always offer a path to a real person and make sure your agents get full conversation context when a handoff happens.
• Inconsistent tone between AI and agents can make disjointed experiences. Align your brand voice across all support channels and choose tools that let you customize AI tone.
• AI works best when its role is clearly defined. Decide which topics it can handle, train it using real conversations, and review performance regularly to fine-tune your setup.

You’ve chosen your AI tool and turned it on, hoping you won’t have to answer another WISMO question. But now you’re here. Why is AI going in circles? Why isn’t it answering simple questions? Why does it hand off every conversation to a human agent?

Conversational AI and chatbots thrive on proper training and data. Like any other team member on your customer support team, AI needs guidance. This includes knowledge documents, policies, brand voice guidelines, and escalation rules. So, if your AI has gone rogue, you may have skipped a step.

In this article, we’ll show you the top seven AI issues, why they happen, how to fix them, and the best practices for AI setup. 

{{lead-magnet-1}}

1. AI sends the wrong answer — with confidence

AI can only be as accurate as the information you feed it. If your AI is confidently giving customers incorrect answers, it likely has a gap in its knowledge or a lack of guardrails.

Insufficient knowledge can cause AI to pull context from similar topics to create an answer, while the lack of guardrails gives it the green light to compose an answer, correct or not.

How to fix it: 

• Update the AI knowledge base. Create a new document that covers the affected topic in its entirety. To ensure AI follows every step, write your instructions in a when/if/then format.
• Define topics that AI should not handle. As a preventive measure, specify the topics the AI should skip and hand over to a human agent. For example, add words such as ‘disappointed’, ‘bad’, and ‘unacceptable’ to your AI off-limit list, so that human agents automatically handle negative-intent tickets.

2. Customer is stuck in an AI loop 

This is one of the most frustrating customer service issues out there. Left unfixed, you risk losing 29% of customers. 

If your AI is putting customers through a never-ending loop, it’s time to review your knowledge docs and escalation rules.

How to fix it:

• Double-check for conflicts in knowledge. You may have provided multiple resolutions for the same issue across different knowledge sources, such as uploaded documents, website pages, and in-app instructions.
• Add “escape routes”. Choose a set of phrases that automatically escalate conversations from AI to your support team. For example, “it’s not working” or “I already tried that”.
• Set a max number of failed interactions before escalation. Opt for a one-fail-and-escalate approach for every conversation, or specify the number of failed interactions for certain topics.

3. AI escalates too quickly, even for easy questions

It can be frustrating when AI can’t do the bare minimum, like automate WISMO tickets. This issue is likely due to missing knowledge or overly broad escalation rules.

How to fix it:

• Train AI on your FAQs and common issues. Which customer questions do you repeatedly receive? Create a document that lists out every question and its answer.
• Update vague escalation rules. AI works best with specificity. For example, if you told it to escalate conversations about “returns,” it may even escalate frequently asked questions about return eligibility.

4. Customers can’t find a way to reach a human

One in two customers still prefer talking to a human to an AI, according to Katana. Limiting them to AI-only support could risk a sale or their relationship. 

The top live chat apps clearly display options to speak with AI or a human agent. If your tool doesn’t have this, refine your AI-to-human escalation rules.

How to fix it:

• Set phrases to trigger escalation. In your knowledge docs, define which phrases should tell AI to hand a conversation over to your support team. For example, “I want to talk to someone” or “Can I talk to a human?”
• Add a visible option to connect with a human. This can be a button in your chat widget, a note in your contact page, or even a link in your website footer. At minimum, give customers an easy-to-find way to reach a real person.

5. Handoff happens — but the agent gets no context

If your agents are asking customers to repeat themselves, you’ve already lost momentum. One of the fastest ways to break trust is by making someone explain their issue twice. This happens when AI escalates without passing the conversation history, customer profile, or even a summary of what’s already been attempted.

How to fix it:

• Use rules to auto-tag conversations based on AI activity. Set up logic to tag tickets when certain conditions are met — like when AI attempted a specific action, couldn't resolve the issue, or triggered escalation.
• Audit your escalated tickets. Look for patterns where context is missing, and adjust the AI-to-human transition logic accordingly.
• Use an AI platform that provides automated ticket summaries. Choose a tool like Gorgias that provides a quick overview of every ticket.

6. The tone between AI and agent is jarring

Sure, conversational AI has near-perfect grammar, but if its tone is entirely different from your agents’, customers can be put off.

This mismatch usually comes from not settling on an official customer support tone of voice. AI might be pulling from marketing copy. Agents might be winging it. Either way, inconsistency breaks the flow.

How to fix it:

• Create shared brand voice guidelines. Align tone, formality, and language rules across both AI scripts and agent responses.
• Define emojis and punctuation use. A consistent visual style helps conversations feel smoother and more human.
• Use AI tools that allow tone control. Choose platforms that let you customize the voice and personality of your AI to match your brand.
• Train your agents with examples of ideal tone. Give your team brand voice examples of how conversations should continue when handed off.

7. You haven’t defined what AI should actually handle

When AI is underperforming, the problem isn’t always the tool. Many teams launch AI without ever mapping out what it's actually supposed to do. So it tries to do everything (and fails), or it does nothing at all.

It’s important to remember that support automation isn’t “set it and forget it.” It needs to know its playing field and boundaries.

How to fix it:

How to set up AI that actually works

Once you’ve addressed the obvious issues, it’s important to build a setup that works reliably. These best practices will help your AI deliver consistently helpful support.

1. Define clear AI boundaries

Start by deciding what AI should and shouldn’t handle. Let it take care of repetitive tasks like order tracking, return policies, and product questions. Anything complex or emotionally sensitive should go straight to your team.

2. Train it using real customer conversations

Use examples from actual tickets and messages your team handles every day. Help center articles are a good start, but real interactions are what help AI learn how customers actually ask questions.

3. Set up fallback triggers

Create rules that tell your AI when to escalate. These might include customer frustration, low confidence in the answer, or specific phrases like “talk to a person.” The goal is to avoid infinite loops and to hand things off before the experience breaks down.

4. Make sure agents receive full context

When a handoff happens, your agents should see everything the AI did. That includes the full conversation, relevant customer data, and any actions it has already attempted. This helps your team respond quickly and avoid repeating what the customer just went through. 

An easy way to keep order history, customer data, and conversation history in one place is by using a conversational commerce tool like Gorgias.

5. Keep tone and voice consistent

A jarring shift in tone between AI and agent makes the experience feel disconnected. Align aspects such as formality, punctuation, and language style so the transition from AI to human feels natural.

6. Review handoffs regularly

Look at recent escalations each week. Identify where the AI struggled or handed off too early or too late. Use those insights to improve training, adjust boundaries, and strengthen your automation flows.

If your AI chatbot isn’t working the way you expected, it’s probably not because the technology is broken. It’s because it hasn’t been given the right rules.

AI that works your way and knows when to escalate

When you set AI up with clear responsibilities, it becomes a powerful extension of your team.

Want to see what it looks like when AI is set up the right way?

Try Gorgias AI Agent. It’s conversational AI built with smart automation, clean escalations, and ecommerce data in its core — so your customers get faster answers and your agents stay focused.

Get started with Gorgias AI Agent →

TL;DR:

• Position Shopping Assistant as a revenue-driving tool. It boosts AOV, GMV, and chat conversion rates, with some brands seeing up to 97% higher AOV and 13x ROI.
• Highlight its role as a proactive sales agent, not just a support bot. It recommends products, applies discounts, and guides shoppers to checkout in real time.
• Use cross-industry case studies to make your case. Show leadership success stories from brands like Arc’teryx, bareMinerals, and TUSHY to prove impact.
• Focus on the KPIs it improves. Track AOV, GMV, chat conversion, CSAT, and resolution rate to demonstrate clear ROI.

Rising customer expectations, shoppers willing to pay a premium for convenience, and a growing lack of trust in social media channels to make purchase decisions are making it more challenging to turn a profit.  

In this emerging era, AI’s role is becoming not only more pronounced, but a necessity for brands who want to stay ahead. Tools like Gorgias Shopping Assistant can help drive measurable revenue while reducing support costs. 

For example, a brand that specializes in premium outdoor apparel implemented Shopping Assistant and saw a 2.25% uplift in GMV and 29% uplift in average order volume (AOV).

But how, among competing priorities and expenses, do you convince leadership to implement it? We’ll show you.

Why conversational AI matters for modern ecommerce

1) Meet high consumer expectations

Shoppers want on-demand help in real time that’s personalized across devices. 

Shopping Assistant recalls a shopper’s browsing history, like what they have clicked, viewed, and added to their cart. This allows it to make more relevant suggestions that feel personal to each customer. 

2) Keep up with market momentum

The AI ecommerce tools market was valued at $7.25 billion in 2024 and is expected to reach $21.55 billion by 2030. 

Your competitors are using conversational AI to support, sell, and retain. Shopping Assistant satisfies that need, providing upsells and recommendations rooted in real shopper behavior. 

3) Raise AOV and GMV

Conversational AI has real revenue implications, impacting customer retention, average order value (AOV), conversion rates, and gross market value (GMV). 

For example, a leading nutrition brand saw a GMV uplift of over 1%, an increase in AOV of over 16%, and a chat conversion rate of over 15% after implementing Shopping Assistant.

Overall, Shopping Assistant drives higher engagement and more revenue per visitor, sometimes surpassing 50% and 20%, respectively.

How to show the business impact & ROI of Shopping Assistant

1) Pitch its core capabilities

Shopping Assistant engages, personalizes, recommends, and converts. It provides proactive recommendations, smart upsells, dynamic discounts, and is highly personalized, all helping to guide shoppers to checkout. 

Success spotlight

After implementing Shopping Assistant, leading ecommerce brands saw real results:

2) Position it as a revenue driver

Shopping Assistant drives uplift in chat conversion rate and makes successful upsell recommendations.  

Success spotlight

“It’s been awesome to see Shopping Assistant guide customers through our technical product range without any human input. It’s a much smoother journey for the shopper,” says Nathan Larner, Customer Experience Advisor for Arc’teryx. 

For Arc’teryx, that smoother customer journey translated into sales. The brand saw a 75% increase in conversion rate (from 4% to 7%) and 3.7% of overall revenue influenced by Shopping Assistant. 

3) Show its efficiency and cost savings

Because it follows shoppers’ live journey during each session on your website, Shopping Assistant catches shoppers in the moment. It answers questions or concerns that might normally halt a purchase, gets strategic with discounting (based on rules you set), and upsells. 

The overall ROI can be significant. For example, bareMinerals saw an 8.83x return on investment.  

Success spotlight

"The real-time Shopify integration was essential as we needed to ensure that product recommendations were relevant and displayed accurate inventory,” says Katia Komar, Sr. Manager of Ecommerce and Customer Service Operations, UK at bareMinerals. 

“Avoiding customer frustration from out-of-stock recommendations was non-negotiable, especially in beauty, where shade availability is crucial to customer trust and satisfaction. This approach has led to increased CSAT on AI converted tickets."

4) Present the metrics it can impact

Shopping Assistant can impact CSAT scores, response times, resolution rates, AOV, and GMV.  

Success spotlight

For Caitlyn Minimalist, those metrics were an 11.3% uplift in AOV, an 18% click through rate for product recommendations, and a 50% sales lift versus human-only chats. 

"Shopping Assistant has become an intuitive extension of our team, offering product guidance that feels personal and intentional,” says Anthony Ponce, its Head of Customer Experience.

5) Highlight its helpfulness as a sales agent 

Support agents have limited time to assist customers as it is, so taking advantage of sales opportunities can be difficult. Shopping Assistant takes over that role, removing obstacles for purchase or clearing up the right choice among a stacked product catalog.

Success spotlight

With a product that’s not yet mainstream in the US, TUSHY leverages Shopping Assistant for product education and clarification. 

"Shopping Assistant has been a game-changer for our team, especially with the launch of our latest bidet models,” says Ren Fuller-Wasserman, Sr. Director of Customer Experience at TUSHY. 

“Expanding our product catalog has given customers more choices than ever, which can overwhelm first-time buyers. Now, they’re increasingly looking to us for guidance on finding the right fit for their home and personal hygiene needs.”

The bidet brand saw 13x return on investment after implementation, a 15% increase in chat conversion rate, and a 2x higher conversion rate for AI conversations versus human ones. 

6) Provide the KPIs you’ll track 

Customer support metrics include: 

• Resolution rate 
• CSAT score 

Revenue metrics to track include: 

• Average order value (AOV) 
• Gross market value (GMV) 
• Chat conversion rate 

Shopping Assistant: AI that understands your brand 

Shopping Assistant connects to your ecommerce platform (like Shopify), and streamlines information between your helpdesk and order data. It’s also trained on your catalog and support history. 

Allow your agents to focus on support and sell more by tackling questions that are getting in the way of sales. 

{{lead-magnet-2}}