Redefining DevOps with AIxBlock & ActivePieces

Kartik MehtaKartik Mehta
12 min read

Table of contents

If you're a developer, DevOps engineer, or Web3 enthusiast, you've probably run into the pain of debugging CI/CD failures and managing automation in decentralised (or centralised) networks. But what if I told you that we could supercharge debugging with AI agents, automate DevOps workflows, and decentralise execution — all without relying on traditional cloud infrastructure?

⚠️ Disclaimer

This isn’t your typical “sit back and read” blog. This is an interactive deep dive that will require you to stick around till the end and perform hands-on tasks to fully grasp how AI-driven decentralised debugging actually works. If you're looking for a quick introductory post, this might not be it — but if you're here to build, experiment, and push the boundaries of DePIN automation, you're in the right place.

Prerequisites

Before we jump in, make sure to explore AIxBlock and ActivePieces on their respective websites. This blog will not be an introduction to these platforms but rather a deep technical walkthrough of how they work together to enable autonomous debugging in a decentralised CI/CD pipeline.

Now that we’ve set the stage, let’s dive straight into building an AI-driven debugging pipeline that works seamlessly within DePIN environments.

What We’re Creating

Our goal? To create an AI-powered debugging pipeline that automates failure analysis using GitHub Actions, ActivePieces, and AIxBlock while ensuring that logs are intelligently formatted and sent to Slack for immediate action.

Here’s what we’ll be building from start to finish:

Step 1: Writing the Breaking Code

We’ll start by writing a JavaScript program with some predefined tests. But here’s the catch — some tests will intentionally fail. These failures will act as real-world debugging challenges that our AI agents will analyse.

Step 2: Triggering the Debugging Pipeline

Whenever we push code to GitHub, a GitHub Actions workflow will:

  • Run the tests

  • Capture the logs

  • Send the logs to ActivePieces, which will then trigger AI analysis on AIxBlock.

Step 3: Log Analysis on AIxBlock

Once the logs reach AIxBlock, a set of AI agents will:

  • Use OpenAI, Gemini, and other models to analyse the failure logs

  • Identify patterns, suggest fixes, and explain errors

  • Format the insights into a structured response

Step 4: Sending AI-Formatted Logs to Slack

The response will be sent back to an ActivePieces workflow, which is listening for responses from AIxBlock. This workflow ensures that:

  • The AI output is structured

  • It is properly formatted for readability

Finally,

  • Take the AI-generated debugging insights

  • Format them into Slack-compatible markdown

  • Send the final structured report to a Slack channel

By the end of this guide, you won’t just understand how to automate debugging with AI — you’ll have built a fully functional decentralised debugging pipeline that’s ready for real-world use.

#1 GitHub Actions → ActivePieces

To get started instantly, fork this repository: AIxBlock-ActivePieces-Kit

I have already set up:

  • A basic JavaScript project with test cases (one will fail intentionally).

  • A GitHub Actions workflow to run tests on every push to main.

Core Files

  • mathUtils.js → A simple JavaScript file with basic math functions.

  • mathUtils.test.js → A Jest test suite that includes an intentional failure to trigger AI debugging.

  • runTest.js → The script that:

    • Runs tests

    • Captures failure logs

    • Sends logs to ActivePieces & AIxBlock for processing

  • .github/workflows/test-and-send-results.yml → GitHub Actions workflow that:

    • Triggers on push to main

    • Installs dependencies (npm install)

    • Calls runTest.js . (Make sure to configure the WEBHOOK_URL in this file, which we will receive in another section.)

Running the Workflow

  1. Fork the repository and clone it:

     git clone https://github.com/YOUR_USERNAME/AIxBlock-Activepieces-Kit.git

  2. Push any changes to main, and GitHub Actions will:

    • Run tests

    • Capture the logs

    • Send these logs to ActivePieces using the web hook

  3. Listening on ActivePieces: (We'll configure this next!)

#2 ActivePieces → AIxBlock

Now that our GitHub Actions workflow is sending failure logs to ActivePieces, it’s time to build the flow to capture these logs and send them to AIxBlock for analysis.

Initial ActivePieces Workflow

  1. Create an account on ActivePieces Cloud. You will then be redirected to the dashboard.

  2. Click on New Flow > From Scratch on the dashboard.

  3. You will be redirected to the page where you can create the workflow. Click on the dropdown for "Empty Trigger." This trigger will listen to the GitHub Actions logs. Search for "Webhook" and then click on "Catch Webhook".

  4. On the right-hand side, you will see the settings for the web hook and the LIVE URL. You need to update this as WEBHOOK_URL in the code (runTest.js, line 4), and don’t forget to append /sync at the end. Leave the other settings as default.

    If you want to test whether this is working, update the WEBHOOK_URL, click on “Test Trigger”, push a commit, and you should receive a response from GitHub Actions in the body of the response, something like this:

{
  "method": "POST",
  "headers": {
    "connection": "Upgrade",
    ...
    "x-real-ip": "172.11.11.11"
  },
  "body": {
    "repository": "AIxBlock-AI-Agent",
    "branch": "main",
    "logs": "{\n  \"details\": \"\\n> aixblock-ai-agent@1.0.0 test\\n> jest\\n\\nFAIL 
            ./mathUtils.test.js\\n  ✓ Addition works correctly (2 ms)\\n  
            ✓ Subtraction works correctly (1 ms)\\n  ✓ Multiplication works correctly\\n  
            ✓ Division by non-zero number (1 ms)\\n  ✕ Intentional Failure (2 ms)\\n\\n  
            ● Intentional Failure\\n\\n    expect(received).toBe(expected) // Object.is 
            equality\\n\\n    Expected: false\\n    001b[39m\\n    \\u001b[31mtal\\nTime: 
            0.509 s\\nRan all test suites.\\n\"\n}"
  },
  "queryParams": {}
}

  1. Now, we need to send this to AIxBlock.

    Click on the plus icon, then search for HTTP and click on it. You will see an option to add a block called "Send HTTP Request." Click on it.

  2. You will see the settings for this section. One of the best features of ActivePieces is that you can use the results from previous blocks here.

    Now, let’s configure the settings as follows:

    1. Method: POST

    2. URL: (don’t worry, we will be creating that right after this step.)

    3. Headers: platform:activepieces

    4. Query params: platform:activepieces

    5. Body Type: JSON

    6. JSON Body:

{
  "repository": "{{trigger['body']['repository']}}", // Data from previous block.
  "branch": "{{trigger['body']['branch']}}", // Data from previous block.
  "logs": "{{trigger['body']['logs']}}", // Data from previous block.
  "webhook": "WE WILL UPDATE THIS WHEN WE BE GOING TO SEND THE DATA TO SLACK. CHILL!"
}

Create AI Agents on AIxBlock

We have completed the initial setup of ActivePieces, and now comes the exciting part — creating the AI Agent workflow on AIxBlock. Let’s get started!

For you: Public page of this AIxBlock Agent.

  1. Create an account on multiagent.aixblock.io.

  2. The first thing you need to do is set up the storage. Click on “Set Storage Now.”

    The easiest setup is to use the AIxBlock storage provided by their platform. Select this option, enter a name, and click Add.

  3. Now, let's add the models that our AI agent will use for log analysis.

    1. Navigate to My Library > Model Management.

    2. On the right-hand side, click “Create”.

    3. Now, you need to add a provider (such as OpenAI or Gemini), specify the model name, and enter the platform-specific API key.

      1. Select a provider (e.g., OpenAI or Gemini).

      2. Enter the model name.

      3. Provide the API key for the selected platform.

      4. Click "Validate" to ensure the configuration is correct.

      5. Add the model based on your preference.

For now, I will add two models: OpenAI and Gemini.

  1. Now, let's select Tools. These tools will help in searching for solutions from the web and retrieving relevant information (RAG).

    1. Go to My Library > Tools.

    2. Click on “Create”.

    3. Some tools do not require an API key, while others do.

    4. For tools like Serper, visit their platform to obtain an API key, then add it to the tool.

    5. Select the tools you need (as specified in the image).

    6. Click “Add Tools” to finalise.

Note: Make sure to add an API key for Serper.

  1. Now, let’s start creating a crew of agents — this is where the real magic happens! A Crew is a group of agents working together to perform a specific task. Go to AI Agents Crew and click on “Create”.

  2. The first step is to add the basic details of the crew. I have attached a screenshot of the values I have selected. After adding them, click "Create". (Note: Add variables, repository, branch, and logs which we will receive from ActivePieces HTTP request.

  3. Next, we need to add the AI Agents (this is what we're here for, right?). I will add two agents:

    1. Log Analyser (Analyses logs, reports problems, provides answers with links. Returns in string format.)

    2. Markdown Formatter (Converts the string text into markdown code.)

I am attaching images of both agents and their details:

Obviously, you can improve the prompts. Also, remember we added the three variables - repository, branch, and logs. We can add them here by using {} and including the variable name.

Alright, so we have successfully created the two agents. Now let's set up the task and flow. Click “Next“.

  1. This is where you create the flow of agents, defining what each will do and what each will return. Now you will be using your agents to create a pipeline where you are going to connect all the pieces. To add a task, click on "Add Task".

    A task consists of the following:

    • Description: A brief overview of what the agent will do.

    • Expected Output: The desired format or content of the output.

    • Raw / Structured Output: Choose whether you want a raw output or a formatted one (e.g., JSON, CSV, etc.).

    • Assign to Agent: Select the agent responsible for performing this task.

    • Context: Any relevant previous task context or knowledge the flow needs to be aware of.

I am attaching an image of what needs to be done so far. Please refer to it.

  1. Click “Next“. Click “Publish now“.

Congratulations! You have created your first AI Pipeline on AIxBlock. You should have received the API endpoint and the JSON schema of what needs to be sent to this endpoint. (This is the endpoint we have created so far.)

  1. Important: Copy the API Endpoint and paste it into the URL field in the ActivePieces workflow, where we are sending the POST request.

Alright! The last thing we need is the Webhook URL, which we will send in this POST request (remember?).

To achieve this, we need to create another ActivePieces workflow that will:

  • Listen to the endpoint

  • Format the AI-generated response

  • Send it to Slack

Let's get started and create this workflow!

#3 ActivePieces → Slack

Let's fix the POST request we need to send to AIxBlock:

{
  "repository": "{{trigger['body']['repository']}}", // Data from previous block.
  "branch": "{{trigger['body']['branch']}}", // Data from previous block.
  "logs": "{{trigger['body']['logs']}}", // Data from previous block.
  "webhook": "LET's FIX THIS URL"
}

  1. Click on New Flow > From Scratch on the dashboard.

  2. You will be redirected to the page where you can create the workflow. Click on the dropdown for "Empty Trigger." This trigger will listen to the response from AIxBlock. Search for "Webhook" and then click on "Catch Webhook".

  3. On the right-hand side, you will see the settings for the web hook and the LIVE URL. You need to update this as WEBHOOK_URL in the JSON body (above), and don’t forget to append /sync at the end. Leave the other settings as default.

Till now, you have configured everything—from GitHub Actions to sending logs to AIxBlock, receiving the AI-generated response, and capturing it again in ActivePieces. Now, let’s format the response and send it to Slack!

  1. Now, we need to format the response we will receive from the web hook.

    Click on the plus icon, then search for “markdown to slack format“ and click on it. You will see an option to add a block called "Markdown to Slack format." Click on it.

  2. On the right-hand side, you will see an input box for entering the Markdown format.

    1. Click on it.

    2. Dynamically insert variables from the received response by selecting them from the list.

    3. Format the message as shown in the image below.

  1. Alright! Now that our response is in Slack Markdown format, the final step is to connect ActivePieces to our Slack workspace and send the formatted message to the selected channel.

  2. Click on the plus icon, then search for “send message to“ and click on it. You will see an option to add a block called "Send Message to A Channel" Click on it.

  3. On the right-hand side, you can see the settings for this block. First, let’s create a connection to our Slack workspace. Click on “Create Connection.” Connect your slack workspace.

  4. After successfully connecting the workspace you will be able to see the list of channels in the dropdown below the connection field.

Note:

Please make sure add the bot to the channel by following these steps:

  1. Type /invite in the channel's chat.

  2. Click on Add apps to this channel.

  3. Search for and add the bot.

If you can't find the channel in the dropdown list (which fetches up to 2000 channels), please click on the (F) and type the channel ID directly.

  1. Select the appropriate channel from the list where you want to receive the message.

  2. For the message, directly select the formatted response from the previous block and leave the other settings as default.

After successfully running this pipeline, you will receive a message on Slack that looks something like this:

Give yourself a pat on the back—you've successfully assembled all the pieces of the pipeline and built your very own Log Analysis Pipeline using AIxBlock! 🎉

Watch It in Action

Seeing is believing! Instead of just reading about how this works, watch the full walkthrough of our AI-powered decentralised debugging pipeline in action.

https://youtu.be/mZJsOskpElo

Now, let’s wrap things up and discuss the future of AI-powered decentralised automation!

Not Just Another Fancy AI Tool

This project addresses a critical gap in modern software development—automating debugging and failure analysis using decentralised AI agents. Traditional CI/CD pipelines rely heavily on centralised platforms, leading to high costs, single points of failure, and limited scalability. By leveraging ActivePieces for automation and AIxBlock for decentralised AI execution, this solution provides a more resilient, scalable, and cost-effective alternative that can be easily adapted across different industries. Businesses looking to streamline DevOps processes can integrate this workflow to reduce downtime, accelerate issue resolution, and optimise developer efficiency.

Beyond its business potential, the value this project brings is in enhancing debugging efficiency and reducing manual intervention in software maintenance. Rather than relying on engineers to sift through logs and identify errors, the AI agent analyses failures in real-time, suggests solutions, and delivers structured insights directly to Slack, making debugging faster and more actionable.

This concept can be extended beyond DevOps—for example, AI-driven cybersecurity workflows that analyse threat logs, or blockchain monitoring systems that detect vulnerabilities in smart contracts. By combining AI reasoning with decentralised automation, this project lays the groundwork for a new standard in autonomous, intelligent infrastructure management.

Thank You for Reading!

If you’ve made it this far, huge respect to you! 🎉

I hope this guide gave you something new to think about and inspired you to experiment with AI-powered workflows in DePIN environments. Whether you’re a developer, DevOps engineer, or just an automation enthusiast, there’s so much potential in combining AI with decentralised infrastructure.

If you ever need help or just want to chat, DM me on Twitter / X or LinkedIn.

Kartik Mehta

X / LinkedIn

20
Subscribe to my newsletter

Read articles from Kartik Mehta directly inside your inbox. Subscribe to the newsletter, and don't miss out.

aixblockactivepiecesDevopscicdautomationAI#ai-toolsBlockchaindecentralization

Written by

Kartik Mehta
Kartik Mehta

A code-dependent life form.