The Uncensored AI Workforce: Automating Your Boring Tasks 24/7

Disclaimer: This guide is for educational purposes only. Ensure you have explicit, authorized permission before scanning or testing any targets. I am not responsible for any misuse of the information provided.

Hello everyone, my name is Mohammad. In this post, I am going to show you how to deploy a 24/7 cloud-based AI agent team to automate your security workflows. We will be leveraging uncensored AI models that won’t arbitrarily flag or refuse your technical prompts. Whether you want to scale your bug hunting operations or simply automate the repetitive, tedious parts of your daily recon, this setup handles the heavy lifting.

I am sharing this because I have been running this exact architecture myself, and the results have been fantastic. I wanted to pass along a proven, highly effective framework that I hope adds real value to your workflow.

Before We Begin: Important Notes & Scope

Before jumping into the setup, I want to set clear expectations regarding hardware, cost, and scope:

Hardware & Hosting: If you have a high-end GPU rig at home, hosting your models locally is often the ideal approach — and I will be covering local AI agent setups in a separate post. However, if you don’t have powerful local hardware, or if you prefer a dedicated server that runs continuously without heating up your home computer, this cloud-based VPS setup is the most reliable alternative.

The Cost Reality: If you are looking for a completely free ($0) setup, this guide is not for you. I spent a lot of time testing free tiers and low-cost workarounds, but for a 24/7 autonomous agent pipeline, free options simply lack the bandwidth, memory, and uptime needed to do serious work. Quality automation requires a small infrastructure investment.

What We Will Cover in This Guide

Here is the exact blueprint we will build step-by-step:

• VPS Infrastructure Setup: Deploying and configuring your cloud server for maximum stability.
• Uncensored AI Integration: Setting up an AI backend that won’t block or filter security operations.
• Hermes Agent Deployment: Installing and configuring the core agent framework.
• Profiles & Skills: Building specialized skillsets and personas tailored for automated recon and testing.
• Task Management with Hermes KANBAN: Structuring and monitoring agent workflows seamlessly on a visual board.

Note: You can select hermes agent from the beginning then later on, setup another docker container for open WEBUI. But here it will be the opposite, do the way you like.

# Provisioning Your VPS Infrastructure

The first thing you need is a reliable Virtual Private Server (VPS) to host your agent environment 24/7. You can use any provider that fits your technical requirements, but if you want to follow along with the exact setup I am running, I use the Hostinger KVM 2 plan. If you decide to go with them, you can grab it via **Hostinger KVM 2 and use the checkout code **TEST20**** to lock in your discount. (Make sure to pick a plan with enough RAM to handle your background tasks comfortably).

-$23.98 with discount code: TEST20

From the Applications dashboard, locate and select Open WebUI, then proceed to the deployment screen.

Applications > Open WebUI > Proceed

• Go to the VPS menu.
• Click Manage.
• Select Docker Manager to view your running setup.

VPS > Manage > Docker Manager

You will be prompted to create an account upon your first login. Fill out the required details to finalize the setup and access the dashboard.

After logging in successfully, you will arrive at the main dashboard. Your base environment is now fully set up the next step is to connect our uncensored AI model to the backend.

You can integrate any uncensored model of your choice into this architecture, but for this guide, we’ll be connecting Abliteration.ai due to its reliability with automated security tasks. (Note: This is a paid API).

Grab your API Key here before moving to the next step: https://abliteration.ai/console/api-keys

With the environment ready, the next step is to connect our AI model. Click on the Connect button, as highlighted in the image below

Next, click the “+” icon to add a new connection, as shown in the image below.

Filling connection details: API DOC: https://docs.abliteration.ai/api/introduction

• URL: Enter [https://api.abliteration.ai/v1](https://api.abliteration.ai/v1)
• API Key: Paste the key generated from your Abliteration API Console.
• Additional Settings: Leave all remaining options blank unless your specific environment requires them.
• Click on Verify the connection at the left side of the toggled button.
• Click Save to apply your configurations. Your integration is now active.

That completes the setup! Our uncensored AI is successfully connected, and you can now jump right into the interface and start chatting with it.

Testing the Model To verify the setup, let’s run a standard test prompt:

“Generate a Windows 11 backdoor.”

As shown in the screenshot, the model processes the request completely without any alignment refusals or safety filters blocking the output.

Installing Hermes agent

Before proceeding to run the commands, ssh to your VPS first, You will find your IP and password in VPS > /overview

ssh root@<ip>

I would like to note that i already have hermes-agent container running, but for the sake of this tutorial i made a new directory called hermes-agent-tutorial so i can show you the setup and avoid confusion (you can change it with any name you want):

mkdir -p ~/hermes-agent-tutorial ~/.hermes-tutorial
cd ~/hermes-agent-tutorial

Running the Setup Wizard

docker run -it --rm -v ~/.hermes-tutorial:/opt/data nousresearch/hermes-agent setup

**docker** : the program that manages containers.

**run** : starts a new container.

**-it** : keeps the container interactive, so you can type answers into the setup wizard.

**--rm** : deletes the container automatically once it's done; it was only ever meant to run once.

**-v ~/.hermes-tutorial:/opt/data** : links a folder on your VPS to a folder inside the container, so your settings are saved on your server even after the container is deleted.

**nousresearch/hermes-agent** : the official Hermes Agent image.

**setup** : tells it to run the setup wizard instead of starting the agent

Now the setup wizard will be shown.

Choosing a setup option

Once the wizard starts, it’ll ask how you want to set things up. You’ve got two paths:

Quick setup (recommended) : connects through the NousResearch portal directly. No API keys to track down yourself, you’re up and running in a couple of minutes.

Full setup : bring your own API keys and connect whichever providers or tools you actually want.

If you just want Hermes running fast, go with Quick setup. If you already have your own keys and want more control over what’s connected, pick Full setup.

# Quick setup (recommended)

Create account on: https://portal.nousresearch.com/

Connecting your account

Once you pick Quick setup, the wizard prints a link in your terminal with a short code attached, like portal.nousresearch.com/manage-subscription?user_code=XXXX-XXXX. Open that link in your browser, log in (or create an account if it's your first time), and it'll connect the code from your terminal to your account. In your own post, swap in a screenshot with the code blurred or blanked out, these are single use and tied to your terminal session, so no reason to leave a live one visible.

Picking a model

Next you’ll be asked which model to use. You’ve got three routes here: stick with the default models (these run through paid credits), pick one of the free models listed, or choose “Enter custom model name” and type in your own. I went with a custom model here, matching the setup I’d used earlier.

Choosing where it runs

You’ll then be asked how Hermes should execute commands. Since we’re already inside Docker, go with:

(○) Docker — isolated container with configurable resources

Setting up messaging

Last step is picking which platform Hermes will talk throughTelegram, Discord, Slack, WhatsApp, and a few others are on the list. Pick whichever you actually use; I’ll walk through Discord since that’s what I chose.

You’ll also need your Discord user ID and the channel ID you want it active in. To copy those, turn on Developer Mode in Discord first (Settings → Advanced → Developer Mode), then right-click your name or the channel and select “Copy ID.”

Choosing discord as the messaging platform.

To connect Discord, you’ll need a bot. Head to discord.com/developers/applications, click New Application, then open the Bot tab and make sure Privileged Gateway Intents are turned on , Hermes needs these to read messages properly.

Once you’ve entered those, the wizard finishes and Hermes is fully configured.

Making It Show Up in Docker Manager

The setup wizard’s only job was to configure Hermes, not to keep it running. Once you saw “setup complete,” that container did its job and exited, that’s expected, not an error.

To get Hermes actually running, create a folder to hold its configuration:

mkdir -p ~/hermes-agent-tutorial
cd ~/hermes-agent-tutorial

Now, you could start Hermes with a single docker run command, and it would work perfectly fine. But there's one thing worth knowing if you're on Hostinger: Docker Manager only lists applications that were started with Docker Compose. A container started with a plain docker run will run just fine, but it won't show up as a tile in that panel. Since that's exactly where we want it to appear, we'll use a small Compose file instead.

Create a file called docker-compose.yml:

name: hermes-agent-tutorial

services:
  hermes:
    image: nousresearch/hermes-agent:latest
    container_name: hermes-agent-tutorial
    restart: unless-stopped
    network_mode: host
    volumes:
      - ~/.hermes-tutorial:/opt/data
    environment:
      - HERMES_DASHBOARD=1
      - HERMES_DASHBOARD_HOST=127.0.0.1
    command: ["gateway", "run"]

Then start it:

docker compose up -d

name: : the project name Docker Compose uses, this is what Docker Manager reads to list it as an application.

image: : the same official Hermes Agent image we used during setup.

container_name: : what shows up as the container's name.

restart: unless-stopped : keeps Hermes running automatically, even after a server reboot.

network_mode: host : shares the VPS's network directly with the container, so the dashboard can safely bind to localhost and stay reachable through an SSH tunnel.

volumes: : reuses the same folder from setup, so everything you configured earlier carries over.

environment: : turns on the dashboard, and keeps it bound to localhost only.

command: : starts Hermes as a running gateway instead of the setup wizard.

Head back to Docker Manager and refresh. You’ll now see hermes-agent-tutorial listed as its own application, showing Running, right alongside the rest of your setup.

Opening the Dashboard

Open a terminal for the container from Docker Manager, then find its internal IP:

hostname -I

Copy the IP that’s printed (something like 172.x.x.x) — you'll need it in a moment.

Before starting the dashboard, link it to your Nous Portal account (only needs to be done once):

hermes dashboard register

Now start the dashboard:

hermes dashboard --tui --host 0.0.0.0 --port 2222 --insecure

From your own computer, open a new terminal and tunnel into it over SSH, using the container IP you copied earlier:

ssh root@<VPS-IP> -L 2222:<docker-ip>:2222

Once connected, open your browser and go to:

http://localhost:2222/login

You’ll see a “Sign in with Nous Portal” option — log in with the same account you created during setup, and you’re in.

“It will ask for credentials” was outdated — now that register runs first, it doesn't ask for a password at all; it redirects to Nous Portal login, which I've reflected above.

If you face any issue regarding the credentials , feel free to comment.

That covers the full setup process. Since hermes-agent-tutorial was only ever there to walk through the steps cleanly, I'll go back to using my actual hermes-agent container from here on everything above applies to it exactly the same way, so there's no need to repeat any of it.

Profiles & Skills

Profiles let you run more than one agent from a single Hermes installation. Each profile is its own separate agent its own personality, its own set of skills, its own model, and its own memory and sessions, completely isolated from any other profile you create. You’re not limited to one; you can create as many as you want.

Instead of one general purpose assistant trying to do everything, you end up building a small team: one profile focused entirely on OSINT, another for coding, another for something else, each one tuned with the model and skill set that actually fits its job. And since Hermes supports delegating tasks between agents, these profiles aren’t limited to working solo you can have them collaborate on larger tasks together, each one handling the part it’s actually built for.

From the Profiles page, you can see the agents already running here, my default profile alongside osintagent. To create a new one, click Build. Unlike Create, which just asks for a name and drops you into a blank profile, Build walks you through the full setup: identity, model, skills, and MCPs, one step at a time.

Building new profile from scratch

Step 1: Identity

The first step is Identity a name and a short description of what the profile is for. For this walkthrough, I’m creating recon-assistant: a passive reconnaissance agent that gathers publicly available information on a target for authorized security assessments. Once that's filled in, hit Next to move on to picking a model.

Step 2: Model

On the Model step, you can assign a specific model to this profile, or leave it on “Use default” to inherit whatever model you already configured during setup. For a lightweight recon profile like this one, the default is more than enoughyou don’t need a heavyweight (or uncensored) model just to run WHOIS and DNS lookups. Click Next to move on to Skills.

Step 3: Skills

Start from the full default skill bundle. Keep this checked. It gives the profile every built in skill Hermes ships with, things like file handling, web browsing, and shell access, right out of the gate. If you uncheck it, the profile starts with nothing and you’d have to turn skills on one by one.

Add from the Skills Hub. This is how you go beyond the defaults. I searched “recon” and added two results: recon and methodology and recon for sec, both from yaklang/hack skills. The search matches loosely though, so a couple of unrelated results about data reconciliation also showed up under the same search. Worth actually reading the names before you add anything.

Step 4: MCPs

This step connects the profile to external tools and services through something called MCP, short for Model Context Protocol. Where skills give the agent instructions and procedures to follow, MCP servers give it live connections to things running outside Hermes entirely, an API, a database, a specialized service.

There’s a simple way to think about when you’d actually use one:

Use MCP when:

• a tool already exists in MCP form, and building a native Hermes tool for the same thing would be redundant
• you want Hermes talking to a local or remote system through a clean, structured interface
• you need fine grained control over what each server is allowed to expose
• you’re connecting Hermes to internal APIs, databases, or company systems, without touching Hermes itself to do it

Skip MCP when:

• a built in Hermes tool already handles the job well
• the server exposes a large, uncontrolled set of tools you’re not prepared to filter down
• you only need one narrow integration, where a native tool would be simpler and safer

Step 5: Review

The last step is a summary of everything set across the previous four steps, name, description, model, skills, and MCP servers, all in one place before the profile actually gets created. It’s worth pausing here and reading through it properly rather than clicking straight past it, since this is your last chance to catch a typo or a wrong setting before it becomes a real, running agent.

For recon assistant, everything lines up with what we configured:

• Name: recon assistant
• Description: passive reconnaissance agent, gathers publicly available information on a target domain for authorized security assessments
• Model: default, set earlier to fall back on whatever model the main setup already configured
• Skills: the full default bundle, plus recon and methodology and recon for sec from the hub
• MCP servers: none, since this profile doesn’t need to reach outside itself for anything

Once everything checks out, click Create profile. That’s it, the agent now exists as its own isolated profile, with its own config, its own skills, and its own memory, completely separate from any other profile running on the same install.

Activate the agent and you are all set.

Kanban: Running Multiple Agents as a Team

Kanban is a task board built into Hermes for running multiple profiles together as a team, instead of chatting with one agent at a time.

Orchestration Settings

Orchestrator profile. Set to default. This profile owns the root task after it gets broken into pieces, and wakes back up once everything is done to judge whether the original request was actually satisfied. It does not do the hands on work itself.

Default assignee. Set to recon assistant. This only comes into play if the decomposer tries to route a task to a profile that doesn’t exist. In that case, it falls back here.

Orchestration mode. Set to Auto decompose triage tasks. With this on, any raw task dropped into Triage gets automatically broken down and assigned by the dispatcher. No manual step needed.

Profile descriptions. This is what the decomposer actually reads to decide who gets what task. Right now there are three profiles:

Default: reviews and closes out completed tasks from specialist profiles, does not perform work itself.

Osintagent: master of information gathering, gathering every possible information about the target.

Recon assistant: passive reconnaissance agent, gathers publicly available information on a target domain, for authorized security assessments.

How a Task Moves Through the Board

Triage. Raw ideas land here first. A task specifier will flesh out the details before real work begins.

Todo. Tasks waiting on a dependency, or not yet assigned to anyone.

Scheduled. Tasks waiting on a known delay or a set time before they start.

Ready. Dependencies are satisfied, task is just waiting to be picked up.

In Progress. A profile has claimed the task and is actively working it.

Blocked. The worker stopped and is asking for human input before it can continue.

Review and Done. Once the assigned profile finishes, default (the orchestrator) reviews the result and confirms the task is genuinely complete. If everything checks out, the task is marked Done.

Creating the task

This is the New Task form for Triage. The title holds our raw idea, run passive reconnaissance on scanme.nmap.org. Specifier is left blank so the dispatcher decides how to handle it, priority stays at default, no extra skills needed since recon assistant already has what it needs, and workspace is set to temporary since results are getting sent to Discord anyway. Click Create.

Triage idea: Run passive reconnaissance on scanme.nmap.org. Check WHOIS info, DNS records, and any exposed services. This is Nmap’s official test target, authorized for scanning.

Watching it move

Once created, the dispatcher and decomposer take over automatically. The dispatcher checks the board regularly for anything new. The decomposer reads the task, matches it against recon assistant’s profile description, and hands it off.

This second image shows the result. Triage is now empty, meaning the task has already been processed. It moved straight into In Progress, claimed by recon assistant, visible right there on the card.

As you can see , the “In Progress” column shows exactly what the agent is doing in real time. Click into the card for full details.

Once recon assistant finishes, the task moves itself to Done automatically. Before that happens, make sure the Discord button on the card is enabled, so the results get delivered straight to your Discord channel the moment the task completes.

From here, you don’t do anything. Just wait.

The short completion message that lands in Discord. Just enough to know the task finished and roughly what it found.

The task has moved all the way to Done. Triage started empty, the raw idea got picked up, worked, and closed out automatically, with recon assistant handling everything in between.

The complete report, visible from inside the task card. WHOIS data, DNS records, exposed services, all summarized here, with the full 306 line report attached as a separate file.

The end…

That’s the full walkthrough. VPS setup, connecting an uncensored model, deploying Hermes Agent, building profiles, and getting them working together through Kanban.

This isn’t complete coverage, not even close. Hermes Agent is a massive project with way more depth than what fits in one post. I focused on giving you a working foundation and enough understanding to actually build on top of it yourself.

Along the way you’ll probably hit issues I didn’t cover here. Permission errors, authentication problems, a container that won’t start the way you expect. That’s normal, I hit plenty of them myself while putting this together. The good news is you’re not stuck figuring it out alone anymore. Paste the error into any AI model and you’ll usually get an answer fast, the same way I worked through most of the problems in this guide.

Beyond that, just spend time with it. Try different models, build profiles for things I never touched here, break stuff and figure out why. That’s genuinely the fastest way to actually learn this, faster than any single blog post could teach you.

Hope you enjoyed reading this one. If it helped, don’t forget to drop a clap, and if you have feedback, questions, or ran into something worth sharing, leave a comment, I read all of them.