Copia’s Ai Copilot Documents, Converts & Writes PLC Code (P228)

Shawn Tierney meets up with Adam and Nick of Copia Automation to learn about their new Ai Copilot's features in this episode of The Automation Podcast. To learn more about Copia's Ai Copilot, check out the "Show Notes" located below the video. Watch The Automation Podcast from The Automation Blog: Listen to The Automation Podcast from The Automation Blog: The Automation Podcast, Episode 228 Show Notes: Special thanks to Copia for sponsoring this episode and making it Ad Free! To learn more about the products covered, see the below links: Copia.io Copilot Launch Until next time, Peace ✌️  If you enjoy this episode please give it a Like, and consider Sharing as this is the best way for us to find new guests to come on the show. Shawn M TierneyTechnology Enthusiast & Content Creator Eliminate commercials and gain access to my weekly full length hands-on, news, and Q&A sessions by becoming a member at The Automation Blog or on YouTube. You'll also find all of my affordable PLC, HMI, and SCADA courses at TheAutomationSchool.com.

Episode Transcript

(00:00):
Welcome back to The Automation Podcast, the world's
number one industrial automation product and technology show.
Thanks to you,
our audience of highly skilled automation professionals. Thank
you for being a member of our audience,
and thank you for tuning back in this
week. Now for those new to the show,
my name is Sean Tierney of Insights and
Automation. And each week, I invite a new

(00:21):
vendor to come on the show to talk
to us about,
products and technologies.
And during their presentation, I play the role
of the audience
asking questions I think you might have as
well as I add my own comments and
questions based on my experience.
Now given that over a quarter of our
audience listens to the show, I will try
to call attention to any details and the
visuals I think you listen only folks may

(00:43):
wanna know about. With that said, it is
my pleasure to welcome Adam back to the
show from Copia along with Nick who's making
his first time appearance here. These guys got
something really exciting to talk about. And so,
with that, let me just turn it over
to you, Adam. In case somebody hasn't watched
our previous episodes,
could you please introduce yourself to our audience

(01:03):
and then pass it over to Nick so
he can introduce himself as well? Yeah. Absolutely.
Absolutely. And, you know, thank you again for
having us. And I think this is now
the 3rd major product launch we've done on
your show.
So thank you for having us throughout those,
and and we're really excited to
share what we've been building internally.
My background is my name is Adam Gluck.

(01:25):
I'm CEO and founder at Copia Automation.
We founded
Copia,
you know, 4 years ago. I should start
working around 5 years ago in order to,
transform the workflows for controls and industrial,
industrial engineers,
increase efficiency,
increase productivity, increase quality, and, you know, ultimately
reduce downtime and build build better production. So

(01:47):
we're super excited to share some of our
vision here and and walk through, you know,
some of the stuff we've been we've been
working on. So,
I'll hand over to to Nick Pupley, who's
a product manager on team. Also, I'll call
out, one one fun data point. He's also
one of the very early
Copia,
users. So he used our product in the
alpha and has since joined the company and
over time worked his way into to being

(02:08):
a product leader here. So I hand over
to Nick. Thanks, Adam, and thanks, Sean, for
having us on the podcast today.
Like Adam mentioned, I was an early user
of Copia back in my previous role as
a controls engineer.
And now at Copia, I'm a technical product
manager,
focusing on our source control team and our
vendor integrations.

(02:28):
I'll give a little bit more background about,
my my history and experience a little bit
later on in the podcast, but for now,
I'll turn it back over to Adam.
Cool. So, yeah, so we view, and, you
know, obviously, this this conversation is about artificial
intelligence and the product we're launching there.
We view this as kind of another piece
of our overall vision. And so for people

(02:49):
who are not familiar with Copia, we're gonna
lead through, know, how we think about industrial
DevOps as an initial step. And then I'll
hand over to Nick, and he'll demo, the
new product that we're launching and kinda walk
through some of the use cases that we're
starting to see within artificial intelligence.
Before we jump into that, you know, AI
is a buzzword
where our culture is, I would say, maybe
an anti buzzword culture internally at Copia. So,

(03:11):
you know, we put a lot of thought
into this before we kind of adopt it
and start building this sort of product. And
one big piece, and you'll see this in
the examples that Nick will will will bring
up later, is really thinking about what are
the workflows
of engineers working really closely with our customers
who are extremely customer centric and product centric
as a business. About 60 to 70 percent
of our headcount goes towards product engineering and

(03:32):
enablement. So working closely with customers,
and making sure that we are building something
that is actually valuable. And so as Nick
kind of goes through, he'll also be talking
through, you know, how how we saw these
kind of use cases for AI play out.
And hopefully, this can kinda contribute to the
the conversation. So we'll go through Covia at
the glance. We'll talk about the overall problem
of industrial DevOps, our current platform today.

(03:53):
I'm a walk through our AI for industrial
code and this kind of way in which
AI impacts industrial DevOps in the same way
that we believe that it's impacted software engineering,
more generally. And then, you know, kind of,
you know, where where we've seen success thus
far with Copia.
So Copia at a glance, you know, as
I mentioned, we're founded in 2020. We started
shipping product to users early 2021.

(04:14):
1 of those users was Nick.
And since 2020, we've raised roughly $30,000,000
of funding from top investors.
We've seen consistent growth and adoption resulting in
2,000 developers from a 135 customers globally.
Our team is this combination of IT and
OT
from a variety of companies, in the industrial
space and in the software space.
And then, you know, our platform in general,

(04:36):
and again, this this focus on customer centricity,
has demonstrated best in class stickiness, really high
user satisfaction, consistent growth and product engagement. And
this is something we also view it ourselves
as bringing to the market as this, you
know, incredible,
user centric approach to developing product,
and building out, you know, a solution that
that really delivers,
value, to our customers.

(04:58):
So the core problem as we view view
it is, you know, 1,000,000,000,000 of dollars of
global production distribution reliant workflows that are are
broken. And so, you know,
if you're a controls engineer in your day
to day life, you're dealing with a variety
of different environments that's hard to build a
consistent workflow over. So you see proprietary file
types, those bespoke protocols,

(05:18):
you you know, really opaque interfaces. Physical file
sharing is is still even today probably the
most common way that we see customers share
their files. So that is a,
you know, on a CD or a USB
or something like that. Marginal testing. So we
see that, you know, basically,
people test in production.
You know, one kind of joke that I

(05:38):
often tell is we talk to a company
that produces, industrial scale water slides,
and they said that they test by going
down the slide. But we see that oftentimes
you were not using tools like automate testing,
emulators, etcetera, and then overall limited visibility into
their production environment. I think when you look
at this,
another lens you can use is to look
at, industrial productivity.

(05:59):
We saw in the late 20th century that
industrial productivity
went up consistently over time and continued into
the early,
21st century. But over the last 15 years,
we actually haven't seen
productivity within the industrial space in North America
grow. And so one of our big visions
is how do we make it so that

(06:19):
people can scale production? How can we create
more industrial automation? How do we make it
so that there's a wider, like, scale and
and and scope
of industrial production? And so we see increasingly
through people using industrial DevOps and our tools,
hyper focused teams
operating at a scale that that they couldn't
operate at before. And we see people being
able to centralize their controls teams and achieve

(06:42):
better standardization and better scale overall, which unlocks
business capability and strategic
value.
And so, you know, we look at this
kind of speed to market ability to build
production, actually set up new production
as a critical piece of what we're trying
to accomplish.
And when we dig in the product, you
know, this is kind of the core of
what we look at when we say that
these workflows are broken. You see here, you

(07:05):
know, a binary diff. You know, this is
what a standard
change management
workflow would look like if you were looking
at Rockwell code with Git given that we
have binary file types. So kind of the
core to our product
is making these workflows
and these
products that don't work with standard off the
shelf IT tool chains
work well,

(07:25):
you know, and in a way that's ergonomics.
As you can see here, this is a
visual diff, you know, of the same code
or similar code.
Similarly, you know, we often talk about DevOps.
DevOps is the outcome of applying the most
trusted principles to the domain of physical manufacturing
leadership, the IT value
stream.
And it's very interesting because you look at
DevOps as a set of practices that we're

(07:46):
almost reintroducing to the the industrial automation world,
but it came out of lean theory of
constraints, the Toyota production system, etcetera. So you
kind of see the circling of knowledge between
the IT and OT space.
But when we talk about DevOps for IT,
it kind of enables, you know, faster workflows.
It enables,
you know, more scale of your engineering teams.

(08:07):
And we often talk about the IT DevOps
approach. And so that starts with get based
source control and collaboration,
which gets to faster recovery, automate testing, which
enables you to catch issues earlier.
Deployment management, we've actually talked to customers and
say it takes them 3 months before they
can deploy a change to production even after
they've made the change because it's so painful
to actually push changes in deployment,

(08:29):
some more efficient deployments,
and then observability and monitoring,
more visibility and changes. So you can actually
say, hey. You know, our code is, from
the moment we finished writing it, it's reviewed.
It's tested. It's deployed in a consistent way,
and that we get observability and monitoring there.
The lack of, DevOps and OT,
really, we see, you know, within the OT

(08:49):
space, a lack of backups and outdated file
storage. As I said, physical storage is the
standard, use case. That leads to extended downtime.
We see manual testing in many cases,
testing in production or testing,
during planned downtime.
So, you know, manual testing frameworks where things
don't always get tested because it's so painful
to test in production,

(09:09):
and people don't run through every test that
they should do. So ideally, we'd have more
emulators, simulators, and automated testing,
manual deployment.
We see just changes are really expensive in
this space, and unlimited is really people don't
really know what's changing in their environment.
On top of this, as we've kind of
moved along, we view industrial DevOps as a
fundamental part of the industrial application layer, and

(09:30):
we start to see this kind of pick
up as you're building out your industrial stack.
You'll build your networking.
You'll build your edge infrastructure.
You'll be building, you know, network observability,
all of this stuff.
And then you have the industrial,
layer that sits on top of that. They're
having access to server review. As people are
writing code in these environments,
they're going to have to invest in DevOps
in order to scale their production environments as

(09:52):
we see increasingly automated production.
And so and we'll go through this pretty
quickly, because people should be familiar with this
who who've seen this before. You know, our
goal is to power the future. And we
say industry x dot o because there's always
a new version of it. We're really looking
at get based source control and collaboration, you
know, bringing this automated testing, deployment management, and
so really monitoring, bringing this whole dev ops

(10:13):
stack to the industrial space is our vision.
Making this work across all of those different
protocols and tool chains. And then increasingly, and
we'll talk about this here, we see AI
transforming the way that software engineers
work. We think that it's aligned with our
vision trying to understand if the same improvements
we see in the IT space, the software
space are possible within the OT space and

(10:34):
start thinking about AI,
enabled workflows,
which we'll talk about our our initial approach
to this today.
But before we get into that, you know,
this is our platform today. Focus hyper on
source control, automated backup.
You know, this is our our source control
solutions. You can see these kind of visual
code changes here.
This is kind of bread and butter of
a good source control practice,

(10:55):
commit graphs, helping people understand what's changing, who's
changing what in their environment.
And then our other core product that often
is useful in the end user market and
people who are just staying production
is, automated backup, and disaster recovery, which is
increasingly par for the course,
within industrial environments, especially as we see IT
and OT conversion,
CIOs and CISOs taking over these environments,

(11:18):
and even regulatory requirements in Europe,
there's a requirement to understand,
what has changed in your platform to have
good backups. So I think we'll see broad
adoption of backup solutions over the next 5
to 10 years. It's just a necessary requirement
in in most production environments at this point.
So if you're not already investing in this,
I think it's something that's that's worth looking

(11:39):
into and just getting ahead of as a
team, and additionally, it has the benefit of
solving for manual backup processes, which a lot
of people do, and letting you start moving
on your your DevOps
mission. So
you can see here some of the visual
job history and and dashboards.
Finally, it's worth calling out because people bring
it up all the time is security. I
mean, we're SOC 2 type 2 compliant,

(12:00):
and we invest heavily in security,
as a business
given that, you know, these environments are, you
know, have critical information and oftentimes critical IP
for our customers.
Obviously, we've been through multiple, you know, enterprise
IT audits and and all that stuff as
well. So we dig pretty heavily into this,
and I think, you know, cloud done right
is actually a

(12:20):
security win compared to, you know, a USB
stick sitting at your desk, or where you're
relying on on physical security.
So that's Copia today.
And that's just a little bit of a
breakdown of what we're doing in in 10
minutes.
Anything in there that you think that you
have any questions on before we jump into
the AI for industrial code piece?
No. I think that was especially the visuals,

(12:42):
I think. And, again, for anybody listening, you
know, this is the 3rd or 4th time
we've had Copia on. So we've we've gone
through these slides before,
but I think the visuals really kind of
followed with what you were saying. Gave a
really just a really good understanding of
why Copia exists
and what you guys do. And I I
think that was a great summary and and

(13:02):
recap, and I'm excited because I've already read
the press release. I'm excited to get into
part 2 of the of the, of the,
show here to talk about what you guys
are doing with AI, which I think the
audience will be very excited about. So let
me turn it back to you.
Yeah. Absolutely.
And just one thing as we jump into
this section too is, like, we're not as
a business, we made a decision not to
do AI for AI's sake.

(13:24):
But since we've seen it have so much
impact within software and engineering, a lot of
people should say that's the kind of biggest
area of impact for AI was cogeneration,
all these tools.
We thought it was worth investing in because
if it's transformative in that space, it's potentially
transformative in the OT space. And that's what
kind of kicked this off and got us
saying that this might be something that's that's
really, really valuable, and we think we've built

(13:44):
something that that that will have a big
impact on engineers,
workflows. And it's a product that we hope
people can use, you know, every day. So
I'll hand it over to Nick, to introduce
himself and and talk a little bit about
the product. Yeah. Thanks, Adam.
Like I mentioned at the top of the
podcast, my name is Nick Buechle,
technical product manager here at Copia. I've been

(14:04):
with the company for almost a few years
now, almost 3.
And a little bit more about my background,
I'm an electrical engineer by education,
who found myself
in the industrial automation and controls industry
pretty early on in my career.
And so I followed the progression as a
controls engineer doing

(14:25):
your traditional controls development for a
custom machine builder OEM here in Minnesota.
Worked my way up
to,
managing the team at that company,
which is where I got introduced to Copia,
because one of my first projects I wanted
to take on was fixing our our source
control,

(14:46):
problem or really lack thereof.
After that, moved to Copia and started out
as a technical solutions engineer
within the sales organization,
which was a great perspective for me to
get to see
you know, be on the other side of,
the user
and talk to people day in and day
out about the problems that they face

(15:07):
and how they are looking for something like
Kopi to solve them.
And then this year, I moved into the
product management role,
where I now, help kind of drive the
vision of the product direction
and have been fortunate enough to work on
this exciting new, project that we're here to
talk to you about today. So we're here
to talk about the the launch of, Copia

(15:29):
Copilot,
which is, our AI for industrial code tool
that we, should have released by the time
this podcast
has gone out. So a little bit of
background about this. Like Adam mentioned,
AI does have a little bit of a
buzzword sense. And
here at Copia, we're very much against
AI for the sake of AI. And so

(15:51):
the core thing that we we thought about
when we started off and set off down
this path
was focusing our guiding light on, we need
to solve problem and pains that our users
face today. It needs to be something that
people actually
need to use and not just something that's
a cool demo. So we've been working with

(16:11):
a handful of close customer partners
over the course of the past few months
in an alpha period
where we've been,
getting their feedback and having them try it
out. And then this next phase is a
is a beta for our cloud customers to
existing customers today to use the tool, in
a free to use

(16:31):
format for for the duration of this.
I'll obviously talk more in just a little
bit about the capabilities of this.
But given that Copia is a vendor neutral
platform, we think we've got a unique position,
especially related to this AI product,
to
have a tool that's
usable across multiple

(16:52):
vendors. You know, many of our customers at
Copia
have a variety of them that they're
using and developing today.
But we started out this project
with,
the focus being first on the Rockwell and
Allen Bradley ecosystem.
And that's just
primarily a function of the resources that we
have. And, we wanted to build something that

(17:14):
was,
again, meets the needs of the customers and
solve those problems.
So we're starting off with Allen Bradley in
Rockwell
and, hope to expand that in the future.
So before we actually see it, I just
want to preface one more thing about the,
the capabilities of this tool. You know, so
for the, those of you who are familiar

(17:34):
with using LLM tools like ChatCheap Team,
you know, the space of possibilities
is pretty broad. There's a lot of things
that you can do.
So we tried to categorize,
at least at the outset,
3 categories that
we expect people to use this tool in,
and those are,

(17:55):
the following.
So the first one is what we call
net new code generation.
This is kind of in a vacuum, you
need to generate a piece of code.
Maybe it's an AOI
for interfacing with a new piece of equipment,
or something of that nature.
The next one is code modification,

(18:16):
which is
similar to the first one,
but it's different in the sense that you
already have an existing body of work.
You already have a program that you want
to modify,
and you want to
make changes and improvements to that.
And
we'll see some examples of this. But
the interesting thing and distinction about code modification

(18:39):
that we
found from talking to these alpha partners is
that
it's not enough that the code
that is generated is correct,
meaning it does what you've asked it to
do.
It's also pretty important that it looks like
the code
that you're
using because
people tend to standardize their code,

(19:00):
to assist with ease of maintenance
and just usability across the organization.
And then the final one is just kind
of the traditional
conversational
question and answer
and code interpretation.
I kind of think of this section as
a digital controls engineer
colleague that you can ask questions of.

(19:22):
And what we'll show here in a little
bit is
the capability of the tool to
look at your code that you give it,
your PLC code,
understand it, and ask questions,
and suggest, you know, improvements and things like
that.
So with that,
we've prepared a few demo

(19:43):
slides here.
Just to preface this, these are all real
prompts and real responses
that the Copia Copilot
has
given to us. This first one is really
focused on that
conversational,
Q and A. So in this example,
my prompt is give me a brief summary

(20:05):
of this program
and its contents.
Now, why would this be useful?
Well, I get a few stories,
of when this could potentially be something that
you'd want to to use.
The first one is maybe you're a technician
who's
using Copia
and

(20:26):
you've been tasked with troubleshooting
some code.
Maybe you're not familiar
at the deep level that, the controls engineer
who wrote the code is with it. You
don't necessarily feel comfortable
making a lot of changes.
With this tool, you can
ask the Copilot,

(20:46):
hey, what's going on in this? To help
you get kind of a lay of the
land
really quickly and easily without you going through
hundreds of lines of code and rungs of
ladder logic.
The other kind of example where you could
imagine
using this as
a very common use case is
you're a company who has deployed a machine

(21:07):
or it's one of your previous deployments within
your own company
that needs service or needs an upgrade.
Perhaps that original engineer no longer exists at
the company or just otherwise unavailable.
You, again, want to be able to quickly
get up to speed and identify the landscape
of this project.

(21:28):
So if you go to the next slide,
we can see the result of this prompt.
So it does what it's, what I asked
it to. It gave me a brief high
level description of all of them.
So it's telling me, you know, this program
controls the conveyor system for moving around PIs
on our production lines. And then it goes
through and enumerates all of the different routines

(21:49):
that are there. So it tells me that
the main routine,
all those other routines,
the alarms routine is responsible for generating a
heartbeat signal and monitoring for alarm conditions.
So the the value of of this specific
example is that
you can very quickly become more familiar and
comfortable with,

(22:11):
a foreign piece of code to you,
and get some questions answered at a high
level. And this is a a big use
case,
that we see comes up comes up a
lot. You know, oftentimes,
people in
maintaining production,
you know, might not even read ladder logic,
or might have limited knowledge of that. So,
there's something that can often be very powerful,

(22:32):
especially for for people who are are maintaining
production environments,
and different people who who aren't quite as
as skilled within automation or or maybe have
a different skill set, but are still kind
of responsible for some controls related stuff. So,
this is really cool. And and the coolest
part about this, honestly, has just been that
that it works so well. Right? I think
this is one of the ones, Nick, where
you were like, this works really well,

(22:52):
when when you when you initially started testing
it here. So
You know, I wanna just jump in too.
I'm looking at the results here, and some
of the things that it's telling me, I
would not have guessed. For instance, there's a
routine
that doesn't have a very descriptive name,
but your copilot
has deduced things from what's in that routine
to give me kind of a summary of

(23:12):
what's in there.
And that can be helpful, especially if you
have a lot of like, a lot of
times the routine names, the program names aren't
like user friendly. So by this going through
and parsing out what's in there, that could
quickly help me if I've not used this
program before.
Maybe
quick quicken my pace and find troubleshooting something

(23:33):
because I could say, okay.
I'm on what I'm looking for is in
that routine there. I would have never guessed
the heartbeat would be in that routine. Why
is it in that? I don't know, but
it is. So now I can just jump
in there and go look at it. Let
me turn it back to you, Nick. Yeah.
That that's a great observation,
Sean.
At Kopi, we've gotten pretty good at understanding
these projects and having

(23:53):
a close understanding of the structure.
And with things
like tag comments and run comments and just
naming of tags,
these AI systems, these LLMs
are surprisingly good at piecing together all of
that context
and and being able to tell a story.
And the interesting thing and the surprising thing,

(24:15):
that we found is that even with projects
that are pretty sparse
when it comes to that additional context like
con comments,
Mhmm. It still does a pretty good job
at
being able to figure out and give it
a a best guess at what's going on.
Of course, you had to train it. You
had to teach it. This is this. That
is that. That's something you guys did uniquely

(24:36):
with the AI and the the model you
built for it that, you know, if I
went up the chat GTP, it would have
no clue what this program was. Am I
correct in saying that? In a sense. So
in the in the true sense of training
for LLM models, we are not
truly training. So the when you think of
LLM,
foundational models, like, I'm just gonna use chat

(24:58):
gpt a lot because I think that's the
most popular. Knows. Yep.
Exactly.
True training involves massive datasets,
CPUs, and and training over the course of
months.
So what we're actually doing with Copia, and
not to go too low level here, but
Mhmm. We're using a one of those foundational

(25:18):
models that's been trained on a a wide
variety of data.
And then we are giving it the tools
and the additional context that it needs
to know how to interpret and understand,
really, what's kind of the mess of information
that's in these files.
And with that,
it it really kind of supercharges

(25:39):
it and and allows us to
give a a much better result
within the context of, the files that our
customers are working on. Yep. And then one
one subtle thing to call out here, we
might have a slide on it later, is
if you notice on the left, the selection
window,
this is integrated into our source control products
or or device link. So if you're backing
up solutions or or you have code in

(26:01):
Copia,
you know, you can open up a repo
and just ask it to summarize that repo
for you. So that's another kind of powerful
or or a subset of the repo because
you see here, it's, you know, the conveyor
station that we're looking at. But I'd wanna
just call out that piece as well that
there's that that nice integration there. So Yeah.
For for those, Studio 5000 users, it looks
like the controller organizer on the left hand
side of the screen. If you're listening and

(26:23):
not watching, we get the summary in the
middle. But on the left, it looks like
the controller organizer,
but it's inside of the Copia,
software. Yeah. So it should be intuitive to
to navigate there. So it really be able
to operate up, opportunity to kinda navigate their
own project files and and but then ask
for this kind of natural language
summary and then continue to to iterate on

(26:43):
that. So We'll actually be able to see
that project navigation in the next example. So
let's go there.
So this next one, this was actually prompted
from,
some customer,
discussions that we've had,
with this alpha group. They asked, could it
convert ladder logic to structured text or vice

(27:04):
versa?
And and before we see what it it
does, I kinda wanna give it some examples
of why you might wanna do that.
So, from my experience
myself
as a controls engineer,
we've had customer projects that where the end
user
has a a standard language. Maybe they only

(27:24):
allow ladder logic
because that's what their
maintenance personnel are comfortable using.
But our library
is primarily structured text.
You may just have kind of a company
initiative to transition one way or the other.
And sometimes
one language
versus the other is just easier to read

(27:44):
as far as the flow of the code
and troubleshooting.
So
to do this translation
manually
is doable,
takes a long time to do. It's quite
tedious,
and it's error prone. It's not immediately
obvious
how to go from one to the other.

(28:04):
And so, what we'll see in this next
slide in this video
is,
an example of me asking
the Copia Copilot to do this translation
and,
the result of that.
So first, we're showing an existing piece of
ladder logic code within the Copia renderer,
the Studio 5000 project. And this is the

(28:27):
one that I want to convert to a
structured text routine.
And then now what we're looking at is
the Copilot interface.
And what we just saw,
what Adam had alluded to in the last,
example,
was since
we're integrated into Copia,
our users have these projects already stored within

(28:47):
repositories
today.
And so instead of needing to find the
file
or export that routine and then upload it
to the Copilot,
We allow you to pick that directly from
the same window,
select it,
and that's essentially the same as attaching it.
And

(29:08):
these types of small,
subtle,
areas where we've
really focused on reducing friction
are
a very
key point of the work that we've been
doing
in reducing that and making this a tool
that's actually something that
people feel happy and,
happy to use.

(29:28):
So I've asked it to convert it.
And what we see now is the Copilot
is giving us a first of all, it's
going to give us a description about what
it did. So it says I've converted this
from ladder logic to structured text. And then
what we can see is a well formatted
structured text representation of that original
sequence routine.

(29:50):
And the neat thing is, is that
the original comments, wrong comments, are still retained.
So it's it's not like it blew away
those.
And all of the original sequence
numbers,
still exist. So it still can be used
within the context
of your project.
Yeah. I remember this is one when you
when you first, got it working. You were

(30:12):
like, this is very cool.
You were I I remember you were pretty
pretty shocked that it it was able to
do this at at this level of quality.
So
Yeah. And you can imagine if if you
were tasked with
converting an entire
library from one to the other,
that could be a
weeks long

(30:32):
endeavor.
This can substantially
increase the time to to doing the conversion
and then not to mention the the
reduction in errors and issues when you've done
that translation.
Guys, that was really cool. And so for
the people who are listening, let's just take
wrong one for example.
We got, like, an x I c, x

(30:54):
I c and then branched around that. We
have an x I c,
o n s, and then that leads over
to a move. And so
what would that look like? And I think
we could all kind of visualize that instruction
text, but, you know, we're doing an either
or here. We have 2 instructions or these
other two instructions. Right? And so when we
look at what it did, it did an
if statement like you'd expect,

(31:16):
and we have open parenthesis and we have
the first
two operators and then we have an or
and then we have another operator
that matches the ladder. So you can really
follow along.
It's in the same order as the ladder
logic,
and you can follow along. You see the
rung comments there are now comments
inside of the structured text.

(31:37):
And,
all Nick did to make this happen is
he selected the the routine he wanted to
convert. He typed in, hey, convert this routine
to from Latitude structured text, and it did
it. And, Nick, am I missing anything here?
No. That's it. I mean, I I suppose
the one thing that I neglected to mention
is is what you do with this after

(31:59):
you got the result, after you see it
on your screen.
And that's something also that we identified really
early on as being a pain point.
Since we can't integrate with the IDE itself,
we've got to do everything we can to
reduce the friction
of
getting the results
to actually

(32:19):
accomplishing the final task, which is getting that
code on the device
and doing the thing that you want.
So
a couple of things that we've done
to make that easier
is, first of all, with structured text, it's
just text. You can copy and paste it
like you would. So you can copy it
and paste it directly into your IDE.

(32:40):
But the other things that we
can do with Copilot
is download the L5x,
and an importable L5x. So if for whatever
reason you wanted to to do that way,
you'd be able to download it,
right click import in Studio, and and add
it that way.
And then
with

(33:00):
results that are generated in ladder logic,
we've actually,
we've done a lot of work to make
that easier as well because that's a little
bit trickier because it's not just text.
And
you can, within Copia today,
select multiple rungs of Rockwell's ladder logic,
click a button to copy it. And then

(33:21):
in your IDE, you can paste that as
neutral text, and they'll get created down there.
And so that's that's about as good as
we can get
without being in the IDE itself for
making that transition from the Copilot
to the actual IDE.
Yeah. And this is again you know, I
mean, we mentioned earlier that while we're a
multi vendor product, we picked 1 vendor to

(33:43):
begin with.
But where we really dug in and and
Nick and the team really dug in was
trying to make sure that these workflows were
ergonomic. And, again, into that hyperfocus on, can
we build workflows that actually work for the
people who are who are using the product.
So,
those small things like how do you get
code out of the copilot into the ID,
we spent a lot of time on those

(34:04):
sorts of things,
because we wanna make sure that we really
nailed the the workflow and made sure that
it was it was,
you know, it worked well for the users
of the product. And the very intense customer
centric, user focused
conversations we have with our alpha customers helped
us kind of smooth out those rough places
in the workflow,
because if people had to then redo all

(34:25):
of this stuff in Ladder and Studio 5000,
it was gonna be painful. But if they
could copy and paste, you know, it's gonna
be a lot easier. Okay. So this next
one's a fun one. And there's been a
lot of examples of this as we've
worked on this project
of
things that our users have asked
that we can do. And the answer was
originally, we don't know, but we'd love to

(34:47):
try it. And so,
one of the alpha users had this problem
where
his team was responsible for
writing,
maintaining, and distributing
the company's,
library of standardized
code.
So they would write
AOIs that controlled their, you know,

(35:09):
communication with a database, for example, or controlling
a robot.
The thing that they were missing, though, is
that
they didn't have the bandwidth and the the
time to
actually do the final step of documenting
these pieces of code
with essentially like an instruction manual.

(35:30):
And the result of that is when people
don't have the instructions,
people are not as likely to follow those
standards.
But it just didn't really rise to the
level of them investing a bunch of, an
engineer's time to write documentation.
And I know I don't like writing documentation.
I suspect that, a lot of the engineers
in the audience

(35:51):
don't either.
So what we're able to do, and we're
going to see here next, is
within Copilot, we're able to ask it to
write a document
describing
the purpose of the AOI,
the intended behavior,
any requirements,
such as inputs and outputs,

(36:12):
and put it into a nice format. And
And so what we're going to be putting
in here in this example is a markdown
formatting,
which is just a nice way of formatting
text.
What we see here, this is again that
project tree. So I have my Studio 5000
project
in my Copia repository
and I selected the AOI

(36:33):
that I wanted to generate the documentation for.
In this case, it's an it's an Alarm
AOI
that I'm sure many people have interacted with
something similar.
So in continuing on, we asked it to
generate that documentation.
And what we see at the end of
this is a list of text of that
documentation.

(36:53):
Now, this has some weird kind of icons.
That's the markdown formatting syntax.
So what the video is showing now is
us putting this into Copia
so we can actually see that formatting.
And this is
how that user ultimately wanted
to store this documentation
because within Compia, it's right next to the

(37:15):
code,
what we're seeing is a really nicely formatted
and well structured
document
that starts off with, here's what this AOI
is intended to do.
Here's a list of inputs
that are needed,
including the data type. So it's calling out
that
the input alarm condition tag is a boolean,

(37:36):
and then the alarm time is a double
integer,
which is representing
the number of milliseconds
for the debouncing,
for triggering the alarm.
And it even gives us,
later down the line,
an example of usage of that AOI in
structured text.
All of this is from

(37:57):
one prompt that you could reuse
and ask for any and all of your
pieces of code within the project.
I was just gonna say for the audio
audience, we saw that markdown language. It was
it was all just text. Right? With the
extra characters that you may not normally see
in a text file. But what those extra
characters did was defining the font size, was

(38:18):
defining
the, you know, should it be bold, was
defining, hey, is it a ordered list or
is it a bulleted list? And even if
it's a code sample, which would, you know,
shows up in a different, you know, with
a different color background, and it looks beautiful.
And I know
if you gave me this AI, AOI and
said, Sean, create this document from from this

(38:38):
AOI, I'd be like, I would get a
headache immediately. It's like, I don't wanna do
that. I wanna do something productive.
So having the AI tool be able to
generate this just from
all the work I've put into my AOI,
you know, I've gone in there, I've described
everything, I annotated everything, you know, having,
the ability for the your your Copilot
to be able to create this documentation

(39:00):
on it is pretty huge. I I'm just
very impressed. It looks so professional.
Yeah. Thanks. It's it's it's nice when the
capabilities allow you to kind of offload some
of the tasks that are not as fun
to do as an engineer, like documentation.
So it's a great
great capability, I think.
Yeah. We saw a customer sit with this

(39:20):
for 3 hours
and generate an AOI for every single,
documentation for every single AOI just like this.
So it's a really powerful way of of
building more documentation.
And then even if you're not the owner
of the AOI and you're consuming the AOI,
being like, how do I use this AOI?
You can go ask,
you know, our our copilot that, and it

(39:42):
will return, you know, this how you use
it. So it's useful both if you're the
owner of the AOI or you're given this
thing that you're supposed to use and you
don't know how to use it. Right? So
and there's no documentation. So it kinda fill
the gap there and and help people be
more more productive.
Yeah. And it's it's not easy to look
at a AOI. You don't when you look
at AOI, you don't see this beautiful

(40:04):
document. Right? You it's it's a piece of
code
and, it can be it can it can
be everybody knows. It's time consuming to read
somebody else's code. Right? So even the best
developed AOI
doesn't doesn't give you this level of, you
know, ease ease of use. You could actually
read this and say, I feel pretty comfortable
with that AOI now. So, I I would
like to know what you in the audience

(40:25):
think. Are you impressed like I am? What
are your thoughts on this? Let me know.
Leave a comment on the show. Send me
a you know, get in contact with me.
I'd like to know what you guys think
about this as well. And let me turn
it back to you, Adam. Yeah. There's one
thing here too. I'm just seeing the second
bullet under limitations, which says the AOI does
not provide build an alarm acknowledgment or latching
functionality. These would need to be implemented externally
if required.

(40:46):
I don't know how it figured that out.
You know? It's pretty cool, and it's pretty
powerful.
Should we go to the next slide? Yeah.
Yeah. So the next couple of slides are
gonna be on, the code generation,
a little bit more depth on that. So
this one's gonna be
this this is that net new generation. So
from scratch, generate me a piece of code.

(41:07):
And so what we're gonna ask it to
do here is is generate me just a
template routine
of a basic sequencer,
of which
most companies will have this concept of a
sequencer.
You know, you might write it in ladder
logic. You might have it in structured text.
What I'm asking you to do is just
generate me an empty one as a as
a boilerplate,

(41:27):
and and leave the rest empty.
And I'm specifying that the sequence should start
on a specific input
input tag, and then it should also restart
automatically when it finishes all the steps.
An additional kind of wrench to throw in
there, I asked it to stop immediately if
there's any alarms or faults. And then I

(41:48):
told it to only use native,
Studio 5000 instructions.
So it doesn't use any
try
to add any AOIs or custom instructions.
And this type of thing,
I see Bean as a very helpful
capability for especially new engineers.

(42:09):
When I started out as a controls engineer,
well, really as an intern,
my first project was tasked with
translating an existing
project from
Rockwell to a Beckhoff system.
And
I didn't have any training. I was just
sat down, looked at the code
and needed to

(42:29):
email coworkers asking questions and just kind of
slog through it.
And with this capability,
you can
kind
of more quickly
get that level of proficiency
and with the additional benefit of not needing
to sit next to and pester a more
senior engineer.
So if we go to the next slide,

(42:50):
we can actually see this demonstrated.
And this would be a quick one because
I'm not selecting any project
to begin with. I'm just giving it the
prompt as input.
And then what we look at here,
is the output. And if we scroll to
the top, Adam, just pause when it gets
there, please.
So we see
a 10 or so rungs.

(43:12):
And
it has an output of this ladder logic,
routine. And then down below, it has a
description of of what it's doing.
But we can see here that on the
first rung, it's saying
if the sequence is if the start signal
has been given
or if the sequence is completed, it's coming
back around, and there's no alarms, we're going

(43:34):
to kick it off.
And then we also see that it meets
my other requirement of if there's any alarms
present or any faults present,
we're going to take the the sequence out
of running mode so that it stops.
And then for the future steps,
it it did what I had asked and
said, just make the steps as a placeholder,
but don't have any actions within that. Just

(43:56):
leave them blank so I can fill them
out,
later on down the line.
So to kind of continue on that, this
next example is is
going yeah. Next slide, please. Yeah. One thing
just to add real quick too is the
rendering itself in the in the browser, right,
of the generated code.
This is something that we invested early in

(44:17):
the process as we said, hey. If if
we're gonna build a code generation tool for
ladder logic,
it needs to actually generate visual code.
And so this is something that isn't anywhere
else on the market as far as we're
aware. And we thought it's kind of a
par for the course. It's kind of back
this idea of making the IT DevOps vision
ergonomic in the OT space, the initial binary
file diff. It's been kind of core of

(44:39):
what Copia is doing is having this code
generation actually also be visual. So I just
wanna call that out because I think we're
used to it now, Nick. But
it was actually that was a big step
for us when we started this project was
can we generate code that we can then,
you know, render in the the browser so
that people can actually have a a a
they it's they can actually use the product.

(45:00):
Yeah. That that's that's a good call because
if you if you're not able to
see it quickly and instead you have to
kind of round trip to the IDE to
verify it and then come back,
iteration, asking it to make changes and and
improvements to the results that it made,
is really, really slow and kind of diminishes
the value. So this is very, very important

(45:23):
that you can actually see the results in
a format that
resembles the the final format.
So we continue on
this example,
by asking it to now modify that code.
This is kind of a
I think an interesting demonstration of the capabilities.
Because what I'm asking it to do,
and I think it's a slightly different sequence

(45:45):
routine,
but same structure,
I ask it to add an additional step,
somewhere between step 203100.
And I give it a little bit more
information and say that step should not continue
unless
the station alarmed bit is not true.
So on the next slide, what we can

(46:06):
see is
the code of that routine
before
the change. If you go to the next
slide, please, Adam.
So it might be a little hard to
see, but on rung 4, we see sequence
step 200. And on 5, we see 300.
And based on my instructions, I want an

(46:27):
additional one in between those two steps.
And go to the next one, please.
So then highlighted in red now is
that newly added
run.
And
you'll notice that it picked the sequence step
of 250. So kind of split the difference
there.
And it did actually
check,

(46:48):
that my
the station alarm bit
is not true before continuing.
And worth pointing out, too, is I didn't
ask it to add a comment to that
rung,
but it actually did say
there's a comment on the rung that says
check if the station is not alarmed
before proceeding.
It kind of has the ability to

(47:10):
make those additions and,
insertions, especially related to code commenting,
when appropriate. And in this case, it certainly
was.
So I think I just have a couple
more examples.
So this one's
a unique one
where I'm asking it to generate a UDT.

(47:31):
So I wanted to show this to demonstrate
that it's not just code
generation
or logic generation in the traditional sense.
I'm asking it to write a UDT, which
is
essentially a custom data type for Studio 5000.
And I've asked it to do for
a create a for a recipe

(47:51):
that's representing an oven control process.
I say it should contain elements around temperature,
target temperature,
DID values, and errors. But I give it
a lot of, latitude to
add any additional
parameters that I'm not thinking of.
Now, is this the most realistic example?

(48:12):
I don't know.
I've never done an oven control, but I'm
guessing that if you're someone who does, you
probably have a very good sense of those
types of values and controls that you want.
But that does not prevent you from specifying
specifically
saying I want a temperature value named
X and on and on.

(48:32):
But this is just it shows that it's
it's kind of has some ability for
creative thought and kind of filling in the
blanks there. So if we go to the
next slide,
I think this is a video demonstration
of me asking it. And, once we get
the response, Adam, we'll just ask you to
pause that, please,
once I get to the,

(48:54):
UDT. So
the interesting thing is, since we've tied this
in with our kind of core source control
and rendering technology,
you'll notice, John, that the
project tree, just like you called out earlier,
which resembles the Studio 5000,
logic tree,
shows us the list there, and it shows
us the UDT

(49:16):
in the location that it would be normally.
And I can click on that and see
a UDT with 7 or 8
tag name, tag elements in there.
And then
continuing on, Adam, you'll even notice that I
didn't tell it to give me a good
description,
but it is kind of

(49:36):
one of the things that we've done is
really biased it towards
being a
thorough controls engineer.
And
we notice here that the cooldown rate,
tag,
they added the comment
Copilot added the comment that says, you know,
this is the cooldown rate in degrees Celsius
per minute, and each and every one of
them has that.

(49:59):
Yeah. That's super cool. We love a rigorous
rigorous AI.
That's super exciting.
And this final one, final example,
is is a real life example from my
previous experience as a controls engineer.
It's a net new generation

(50:21):
Where my company had a standard
piece of code for controlling those tower lights
that you'll often see on top of machines
with the green, yellow, and red lights.
But our end customer had a different behavior
of those lights where they wanted,
the red light should flash,
you know, with a 50% duty cycle when
the machine is experiencing an alarm,

(50:42):
and the yellow light should be on when
the machine is not actively running.
So what I do in this prompt is
specify the behavior.
And, you know, had I had Copilot back
then, I probably could have just copy and
pasted the requirements that they had listed down
in their
requirements document
and asked it to implement this.
But I go ahead and ask the

(51:06):
Copilot to generate this AOI.
And what we're gonna see on the next
slide is,
I believe a video demonstrating
that.
So I give it a long
maybe not long, but I give it a
good,
thorough explanation of what I want.
And
the result of that is a simple piece

(51:28):
of code
that represents the routine that's doing,
controlling those lights and the behavior of them,
just as I had described.
And if you maybe can go there and
pause that, Adam, so we can just take
a look.

(51:48):
So if we look at rung 0,
the green light is on when there's not
an active alarm.
And
we see that the red light on rung
2,
as well as the alarm,
both get activated
and start
flashing
when there is
an alarm active within the program.

(52:09):
So this has saved me
some amount of time, you know, maybe 10
minutes
to write this up and change it. And
I can,
just like I mentioned earlier,
import that directly into the project and start
using it immediately.
Yep.
Great.

(52:31):
Anything else on that? And then I can
add 1 or 2 other things just for
people's consideration as they're thinking about using and
engaging with the tool.
I think that's it. Hopefully, those examples kind
of demonstrated
some of the possibilities and capabilities,
of the Copilot tool,
and we're really excited to see all the
new ones that people come up with when
they start using it.

(52:52):
Yeah. It's been honestly
I think on my end as we've built
this out and I've been watching you and
the the team engage with this and,
the tool is kinda understanding, you know, what's
and and also the, early alpha customers is,
you know, what can this tool do well?
What can it not do well? I'm starting
to feel that out. I think one really
interesting thing too that that we saw across
different customers is there's a learning curve associated

(53:14):
with some of these tools as well. So
you notice that some of these prompts are
really well structured and, you know, all this
stuff as well. That same learning curve, I
think sometimes
people think they run into these sorts of
learning curves. They're like, oh, we're just, you
know, experiencing this for the first time or
it's on the platform. You know, a lot
of those learning curves exist
within, you know, software GPT as well. So
when you're generating Java or c sharp or

(53:36):
whatever, you know, you often see you have
to structure the code the right way and
and send the right sort of prompts in
in order to get the result you want.
So there is kind of a learning curve
that people go through with this. So as
people, you know, adopt the tool and and
use it, you know, just kinda keeping that
in mind of, you know, this is what
well structured prompts look like, and the result
will be better based off the the quality
of the actual prompt that you put in.

(53:57):
The other thing I just wanna call out
here is in terms of how these tools
get used is, like, we don't provide a
guarantee that the code works,
on the first code generation.
You still have to bring it into Studio
5000 and test it. You might even modify
the code and do some things a little
bit different, but the goal there is to
get you an 80% improvement.
So, you know, how do you you know,
the sequencer example is when I think about

(54:18):
where you're like, this is repetitive code to
write. Let's just get it going, and then
I can kinda go from there. And that's
similar to how code generation gets work used
in the software space. And people generate some
code and they'll bring into their project, but
then they still have to adapt it to
the project and the environment they're in as
well.
So I just wanna call some of those
things out, you know, as people come to
the tool is it's a goal. The goal

(54:39):
is to speed you up to bootstrap,
you know, repetitive code or, you know, building
out a UDT is a great example of
this and make it so that you can
actually just move a lot faster. And that's
why you see that, you know, sometimes we'll
say even 30, 40% productivity
improvement
for software engineers using,
you know, code automation. So,
all this stuff is goal is to make
it so that you're more productive and able

(55:00):
to do more work, as an engineer, whether
you're sustaining production.
You need the documentation, the natural language, and
the AOI documentation, or you're developing new code
from from scratch.
This is really powerful, and and thank you.
Thanks for for demoing that, Nick. Yeah. Absolutely.
I think that was great. I can definitely
see it's easier to type in. Create a
UDT that does this, this, and this than

(55:21):
it is to actually go on the GUI
and
create it all, you know, manually. So especially,
like, if you have if you have to
create 200 rungs, and it's gonna be a
sequence like you had there, it would be
easier to say, hey, create this 200 run
program that does x, y, and z, and
just have it generate the code. That's a
lot of typing that you didn't have to
do
because it it it understood what you wanted

(55:42):
and it did all the work. It's it's
almost, you know, analogous to what we did,
you know, 20 years ago when, you know,
we just you know, people discovered Excel or
or maybe it's 30 years ago.
And they're like, I can just click the
corner and drag and it fills it or
populates everything. So Yeah. It really just is
a super
usability and and time saver
for for our engineers who are at BNS

(56:04):
to do more and more every day. So
let me turn it back to you, Adam.
Yeah. Absolutely. Yeah. No. And I I think
the time saver I mean, for me, when
I was a software engineer and writing code
every day, I used to always say there's
a lot of manual labor involved with just
being all the things you need to type.
And some of that work is actually not
the most exciting part of the role. It's
often exciting to figure out how do I
translate this process I was given
into a overall cohesive system and, you know,

(56:27):
hopefully, enables people to be more highly leveraged,
and be doing more impactful and exciting work
in their their day to day workflow as
well as opposed to writing boilerplate. You know?
So
cool.
You know, just kinda roll this out, you
know, more outcomes.
You know, thinking about DevOps, kinda bringing back
the overall DevOps story. You know, we work
with customers

(56:47):
across the,
you know,
across almost every industrial vertical,
from packaging and distribution
to,
you know, discreet to
water treatment, utilities, etcetera. Like, we we work
across, you know, a bunch of different industrial
verticals,
hundreds of customers.
You know, and as I mentioned, our goal

(57:08):
is really to deliver value to those customers
and make sure that we are having
a substantial impact there.
Again, you know, where we try and differentiate
in the market is to be able to
have a standardized workflow that integrates across every
vendor. And a lot of the core work
we do is
integrating with additional vendors.
So, you know, with this copilot product, we're

(57:28):
starting with Rockwell, but assuming that we get
to a workflow that works really well with
Rockwell, then we wanna kinda spread those and
scale them to other vendors.
And then, you know, again, we see results
in these cases. This is a public case
study with Amazon reduction on unexpected downtime due
to code error, reduction of resolution time for
severe code issues. So we see this,
actual impact of adopting these practices,

(57:50):
and we work, you know, across different,
industrial,
horizontal,
verticals. So we work in in basically almost
every every industrial vertical.
And then again, you know, we've worked with
a variety of customers.
So we see, you know, impact on output,
impact on on workflow. Covia has been life
changing.
AWC
has an amazing customer saying it is a

(58:12):
part of our daily operations,
using the product every day,
a couple of hours per person per week,
we often hear with our source control products.
So, you know, we can see across all
of these, great customers that we work with,
you know, incredible impact,
in their day to day workflows. It enables
you to do more with your controls engineering
team as you're adopting these practices. We're hoping

(58:32):
AI is even more of an accelerator as
people really dig in and and start to
figure out how to use cogeneration productively in
their workflows,
manage to use, you know, documentation
to learn the code and and set context
more quickly so they can onboard into projects
more easily. You know, we're hoping that we
see and and then also using, you know,
our tool to to modify their code and

(58:53):
and actually, you know, develop.
So it's it's super exciting, and and we're
hoping this becomes another piece of this overall
story
of of impact. So,
with that, any any other questions
or any other, kind of, thoughts that you
have, as as we're digging through this? I
would just say that it sounds like from
the beginning of the, the show

(59:14):
that if somebody is a customer, that they're
gonna have access to the beta. Is that
correct?
Yep. So our open beta,
is launching
in, you know, a a week or so.
I guess it will be launched by the
time people are listening to this.
And if you already are a Copia customer,
you have access to our open beta immediately
for free in your product.

(59:36):
The reason that we're doing an open beta,
again, we keep talking about customer centricity solving
real problems. We wanna see this as a
product that people can use every day. Our
existing product, we we track stickiness index,
which is a people that use our product
every month, how many are using every day.
And we see, you know, a third of
our customers who will use the product once
in a month are using every day. It's
an indispensable part of their workflow.

(59:56):
And so we wanna see that same level
of stickiness and engagement with this tool to
know that we really solved a problem for
people before we worry about, you know, how
do we monetize or any of that stuff.
It's really focused on, are we building something
that is valuable,
you know, and is solving a real problem.
So it sounds like if you're if you're,
potentially a large customer, you could have some

(01:00:17):
influence on, you know, as as the Alfa
customers have already
some influence on this product and how it's
developed through its beta stages. So, if this
is something you're looking for guys, please get
in touch with the folks over at Copia,
and, they'd be happy to to to work
with you on that.
Adam and Nick, was there anything else you

(01:00:37):
wanted to cover?
Yeah. I'll add if you're not a Copia
customer and you're really interested in using this
tool, still reach out. Right? We we can
probably figure something out. So,
our goal is really to learn and work,
you know, in a in a in a
close way with, users and and customers. And
and as I said, make sure we're we're
solving real problems and that we're bringing a
tool that that adds real value. So don't

(01:00:58):
hesitate to reach out. You know, that's why
we're we're talking about this publicly.
Well, guys, I'm I wanna just thank you
again for coming on the show and going
through this. It's exciting new product. I really
love where you're going with this, and I
really appreciate you coming on the show. Again,
the show, a new product to our audience.
Thank you, guys. Yeah. Thanks for having us.
Yeah. Thank you so much for having us.

(01:01:18):
This is always a really fun show, and
it's great to be able to go deep
on the product. And we really appreciate the
questions
and thoughtful insights. Well, I hope you guys
enjoyed that episode. And I wanna thank Adam
and Nick for coming on the show to
tell us all about their new, Copilot AI
that they're integrating into Copia.
And, if you're a cloud customer, of course,
you can try that out right now. And

(01:01:39):
I wanna thank Copia too for sponsoring this
episode, making it ad free. Wasn't that great?
No ads? You guys know I love it
when they're ad free because not only do
you guys don't have to listen to ads,
it kinda pays for a person to edit
them. Otherwise, it's a really a complete loss.
So thank you to them. And I wanna
thank our members who help keep our shows
going. Really appreciate you guys. And I'll just

(01:02:00):
thank all of you listeners. You know, if
you did enjoy this episode, please give us
a like, a sub, and a share. And
if you're on the audio platforms, please consider
giving us a 5 star review because that
really helps us grow the audience. And you
guys heard this before, helps us find new
vendors to come on the show. And, you
know, I'm still running into vendors who've never
heard of the automation podcast. So I really
appreciate you guys spreading the word. And with

(01:02:22):
that, we are on our reduced holiday hours.
Just trying to get through all the commitments.
I'm just one guy. So gotta complete all
the commitments I have for 2024
to all my great vendors and customers. And
so I'm working on those, and we do
have more shows like this coming. We have
more podcasts already recorded.
So, we're not gonna leave you blind. I
got another great show coming out tomorrow. It's

(01:02:43):
an episode of the automation show where I
show you how to convert SIC 500
programs
to the brand new tool. Probably a tool
you guys have never seen before. So check
that out. That is a video over at
the automation blog and on YouTube. And with
that, I just wanna wish you guys all
an awesome week. I wanna wish you good
health and happiness. And until next time, my

(01:03:05):
friends,
peace.