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:
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
The response will be sent back to an ActivePieces workflow, which is listening for responses from AIxBlock. This workflow ensures that:
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:
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:
.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
Fork the repository and clone it:
git clone https://github.com/YOUR_USERNAME/AIxBlock-Activepieces-Kit.git
Push any changes to main, and GitHub Actions will:
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
Create an account on ActivePieces Cloud. You will then be redirected to the dashboard.
Click on New Flow > From Scratch on the dashboard.
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".
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": {}
}
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.
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:
Method: POST
URL: (don’t worry, we will be creating that right after this step.)
Headers: platform:activepieces
Query params: platform:activepieces
Body Type: JSON
JSON Body:
{
"repository": "{{trigger['body']['repository']}}",
"branch": "{{trigger['body']['branch']}}",
"logs": "{{trigger['body']['logs']}}",
"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.
Create an account on multiagent.aixblock.io.
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.
Now, let's add the models that our AI agent will use for log analysis.
Navigate to My Library > Model Management.
On the right-hand side, click “Create”.
Now, you need to add a provider (such as OpenAI or Gemini), specify the model name, and enter the platform-specific API key.
Select a provider (e.g., OpenAI or Gemini).
Enter the model name.
Provide the API key for the selected platform.
Click "Validate" to ensure the configuration is correct.
Add the model based on your preference.
For now, I will add two models: OpenAI and Gemini.
Now, let's select Tools. These tools will help in searching for solutions from the web and retrieving relevant information (RAG).
Go to My Library > Tools.
Click on “Create”.
Some tools do not require an API key, while others do.
For tools like Serper, visit their platform to obtain an API key, then add it to the tool.
Select the tools you need (as specified in the image).
Click “Add Tools” to finalise.
Note: Make sure to add an API key for Serper.
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”.
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.
Next, we need to add the AI Agents (this is what we're here for, right?). I will add two agents:
Log Analyser (Analyses logs, reports problems, provides answers with links. Returns in string format.)
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“.
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.
- 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.)
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:
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']}}",
"branch": "{{trigger['body']['branch']}}",
"logs": "{{trigger['body']['logs']}}",
"webhook": "LET's FIX THIS URL"
}
Click on New Flow > From Scratch on the dashboard.
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".
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!
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.
On the right-hand side, you will see an input box for entering the Markdown format.
Click on it.
Dynamically insert variables from the received response by selecting them from the list.
Format the message as shown in the image below.
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.
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.
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.
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:
Type /invite in the channel's chat.
Click on Add apps to this channel.
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.
Select the appropriate channel from the list where you want to receive the message.
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.
Now, let’s wrap things up and discuss the future of AI-powered decentralised automation!
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
