My Clio Review: A Week with the AI DevOps Copilot

I've been playing around with GPTScript lately, making different demos that have helped me decide what to cook using my grocery photos to build a code reviewer for GitHub actions. I’ve seen the power and ease that AI brings to different tasks.

So when Clio, an AI-powered copilot for DevOps built on top of GPTScript, was announced, I couldn’t resist trying it out. I already had a list of tasks that I wanted to perform using it. Further, I've enjoyed using AI directly from the command line, which makes it versatile as a standalone CLI or in automated workflows.

Over the last few weeks, I’ve been tinkering with Clio, performing different tasks, testing it, and seeing how it performs. In this post, I’ll share my experience using Clio, its pros and cons, and whether I think it's really special or just another tool.

But What is Clio?

Clio is an AI-powered copilot that assists with DevOps-related tasks using command-line interface (CLI) agents. It leverages OpenAI's capabilities to provide intelligent, context-aware assistance directly from your terminal, making managing complex workflows and different cloud environments easier.

Installing Clio is as simple as running

and you can instantly get started by using your own OpenAI API Key or your GitHub account if you don’t have an API key.

Key Features

• Preconfigured Agents: Clio comes with built-in agents for Azure, GCP, AWS, GitHub, and Kubernetes, which makes it ready for most common platforms and use cases.
• Customizable: You can build and add your own agents using GPTScript, similar to tailoring Clio to your specific needs.
• Extendable: Clio’s capabilities can be easily customized and enhanced without writing extensive code, making it accessible even for those with minimal coding experience.

My Experience Using Clio

Over the last week or so, I’ve used Clio extensively to perform various actions to support my daily tasks. As a developer advocate, I often find myself building different demos using different tools and platforms. And more often than not, the learning curve to learn and do something new is quite high.

That’s where I’ve used Clio to deploy services, configure settings, and manage workloads—all through simple prompts. Clio handled it easily when setting up virtual machines, configuring Kubernetes clusters or managing storage accounts. Further, the ability to interact with these platforms without constantly referring to documentation or commands has been a huge time-saver.

I want to point out that Clio is being actively developed, which means new features are being added, existing ones are being improved, and bugs are being squashed. I’ve been using Clio v0.1.4 and noticed a few improvements, so I can guarantee that the rough edges will be smoothened in the upcoming releases.

Let me share with you all the things that I liked and things that could be improved with Clio.

Things That I Liked

As I spent more time with Clio, I noticed several standout features that made it a valuable tool in my DevOps toolkit. Here’s a closer look at what impressed me:

Ease of Installation and Setup

With just a single line to install, getting started with Clio is incredibly quick. It doesn’t require many dependencies or services running in the background, making it hassle-free to set up. This simplicity is a big plus, especially when diving into tasks without dealing with complex configurations.

No Need for an OpenAI API Key

One of the most convenient aspects of Clio is that it doesn’t force you to have an OpenAI API key to use it. You can simply connect your GitHub account and start working right away. This makes it accessible to a broader audience, lowering the barrier to entry.

Compatibility with Multiple Cloud Providers

Clio has preconfigured agents for different cloud providers like Azure and Google Cloud, making it versatile across platforms. I quickly created clusters and deployed applications on GKE and AKS without additional tools or scripts.

This compatibility simplifies multi-cloud operations, streamlining workflows across different environments.

Contextual Understanding and Relevant Tool Usage

Clio’s understanding of context is impressive. For example, when I asked it to deploy WordPress on a VM, it knew what WordPress required, performed an update, and installed all the pre-requisites on the VM.

It downloaded WordPress and realized that MySQL and Apache must be configured for WordPress to work correctly. So it first configured MySQL (everything including database, users, etc.) and then installed and configured Apache host files.

This intuitive, context-aware assistance reduces the need to remember specific commands and tools, making workflows smoother and more efficient.

It Explains the Steps It’s Going to Perform

Every time I gave Clio a task, it first outlined the steps it would take before executing them. This feature is incredibly useful if you’re unfamiliar with a process, as it helps you understand what’s happening under the hood.

For instance, when I asked it to create a VM on Google Cloud and deploy WordPress, it detailed the steps and highlighted the necessary configurations, making it easier to follow. If you’re working with Kubernetes, it will also give you YAML files and configurations.

Intelligent Retry Mechanisms

Clio’s persistence in getting tasks done is extraordinary. If a command didn’t execute successfully on the first try, it would intelligently tweak the commands and retry until it worked. For instance, when MySQL was installed and configured, there was an error in the command, and when it was told about this, it retried with a different command and parameters.

This feature shows that Clio knows the nuances in command execution, ensuring tasks are completed despite minor hiccups.

Quick and Detailed Debugging

While deploying WordPress, Clio recognized the need for Apache and made changes to the host files so WordPress could run correctly. When it was told that there was an error starting the Apache service, it went through the logs and found out that there was an error. Which it fixed and executed the next command.

This level of detailed debugging makes Clio a powerful co-pilot in troubleshooting and maintenance tasks.

Areas of Improvement

While Clio has a lot going for it, and I’m finding it helpful, some rough edges still need smoothing out. Here’s where I think Clio could improve:

Abrupt Session Interruptions Requiring Restarts

There were times when my session with Clio was terminated abruptly, sending me back to the terminal without warning. I wasn’t sure what caused these interruptions, but they were frustrating.

Each time, I had to restart the session and re-enter my prompts, which disrupted my workflow and added unnecessary steps to the process.

Lack of Status Updates During Long-Running Actions

One of the more noticeable issues was the lack of feedback during long-running tasks. For example, when I asked Clio to create a Kubernetes cluster on GKE, the process took around five minutes. During that time, there were no status updates or progress indicators, leaving me unsure if the task was proceeding correctly or if an error had occurred.

Fortunately, I had the GCP console open in another tab so I could confirm it was still provisioning, but without that, I would have been left in the dark.

Disappearance of Previous Prompts/Steps After Follow-Up Commands

In several instances, I noticed that Clio would overwrite previous prompts with new outputs in the console. This meant that when I tried to scroll back to review what I had asked earlier, the prompts were gone.

While not a critical issue, having the ability to reference earlier commands would help track what’s been done and understand the context of ongoing tasks.

Parallel, Simultaneous Agent Tasks Don’t Always Work

I tried asking Clio to create clusters on both GKE and AKS in the same prompt. While it initially understood the request and listed the steps, it only executed the task for GKE.

After that, it seemed to lose track of the AKS request, either forgetting the context or struggling to switch between cloud environments. This limitation in handling multi-cloud operations within a single prompt can be a hindrance, especially for those working across various platforms simultaneously.

Summing It Up

After having used Clio for over a week for my daily tasks, it is an exciting tool that showcases the growing role of AI in DevOps. Its ease of installation, contextual understanding, and ability to integrate seamlessly with multiple cloud providers make it a valuable asset for anyone looking to streamline their workflows. My favorite feature here was its ability to retry if there’s any failure and use different commands to get it working.

However, there are areas where Clio still needs refinement. While not deal-breakers, they impact the overall experience. The lack of status updates during long-running tasks, the occasional abrupt session interruptions, and the inability to handle multiple cloud operations simultaneously are some aspects that can be improved.

Overall, if you’re into DevOps and perform many tasks using various cloud providers, Kubernetes and GitHub, Clio is a good sidekick for you. While I’ve shared my opinions here, go ahead and give Clio a try and see how it fares.

For the latest updates on Clio, follow @Clio_ai on X.