How to Connect Nous Research Hermes Agent to QuillBot AI Detector

In a 2026 content quality benchmark, QuillBot's AI Detector achieved a 75% to 80% detection accuracy on long-form English text, matching GPT-4 and Claude detection signatures with minimal false positives [Tekpon 2026 Guide]. Connecting Nous Research Hermes Agent to this detection model creates an automated, self-healing pipeline for verifying generated content quality.

Nous Research Hermes Agent is an open-source autonomous agent framework released under the MIT license. Unlike standard stateless chatbots, it runs as a persistent assistant on a local computer or cloud container. The framework learns from experience, remembering user preferences and workflow context across sessions. It represents its capabilities as portable, on-demand skills that comply with the agentskills.io open standard.

Skills are stored in the agent's filesystem under the ~/.hermes/skills/ directory. Rather than loading every skill simultaneously, the agent uses a progressive disclosure model to save context tokens. It lists active capabilities and loads the specific skill contents only when the active task requires them. To connect the agent to QuillBot, you must define a custom skill folder containing a YAML-configured Markdown definition and a Python script to communicate with the external detector endpoint.

This integration lets developers automate text scanning directly at the workspace level. Rather than manually copying generated text, the agent runs the custom skill programmatically on newly updated files. This saves computational time and prevents human copy-paste errors.

To define the capability, create a new directory named quillbot-detector in the skills root:

mkdir -p ~/.hermes/skills/quillbot-detector

Inside this directory, write a SKILL.md file. The prompt builder in Nous Research Hermes Agent parses the YAML frontmatter at the top of the file to determine parameters, platform compatibility, and triggers. Keep the frontmatter block concise to prevent parsing errors.

Below is the complete SKILL.md template:

---
name: "quillbot_detector"
description: "Scans text documents to check for AI-generated sentences using QuillBot's content detection model."
version: "1.0.0"
platforms: ["macos", "linux"]
metadata:
  tags: ["ai-detector", "text-analysis", "content-quality"]
  category: "utility"
---

### QuillBot AI Detector Skill

This skill allows the agent to scan written content and return the probability of machine generation.

### Usage

Provide the agent with a block of text or a file path. The agent will run the check and return the report.

#### Arguments
* text: The text string to analyze (minimum 80 words, maximum 1200 words).
* file_path: Path to a text file in the local workspace containing the text.

The agent processes these arguments when executing the skill. If the user requests a scan, the agent extracts the arguments and executes the Python worker script. The skill metadata directs the agent to look for the script within the same folder, simplifying execution.

In larger development teams where multiple agents coordinate on a single server, naming collisions can occur. Hermes Agent supports namespaced skill names, allowing you to name the skill company_name/quillbot_detector instead of a flat name. This is particularly helpful when managing different variants of verification skills.

The prompt builder retrieves these configuration variables from the agent's main configuration. When the skill is loaded, these variables are injected into the agent's context window. This progressive disclosure pattern ensures that the system does not waste tokens on unused instructions.

Since QuillBot does not provide an official public API for its AI detector, you must route your agent's requests through a web service wrapper or a third-party gateway. The execution script below uses a RapidAPI wrapper to communicate with the detection system. The script takes the input text, verifies that it meets the length criteria, and returns the machine-generation score.

Create the file scan_text.py in the skill folder:

import json
import os
import sys
import requests
def scan_text(content):
    if len(content.split()) < 80:
        return {"error": "Text must contain at least 80 words for reliable detection."}
    url = "https://quillbot-ai-detector-unofficial.p.rapidapi.com/v1/scan"
    api_key = os.getenv("QUILLBOT_RAPIDAPI_KEY")
    if not api_key:
        return {"error": "API key environment variable 'QUILLBOT_RAPIDAPI_KEY' is missing."}
    headers = {
        "content-type": "application/json",
        "X-RapidAPI-Key": api_key,
        "X-RapidAPI-Host": "quillbot-ai-detector-unofficial.p.rapidapi.com"
    }
    payload = {
        "text": content,
        "language": "en"
    }
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=15)
        response.raise_for_status()
        data = response.json()
        return {
            "score": data.get("ai_percentage", 0.0),
            "sentences_flagged": len(data.get("flagged_sentences", [])),
            "raw_response": data
        }
    except requests.exceptions.Timeout:
        return {"error": "Connection to the detection endpoint timed out."}
    except requests.exceptions.HTTPError as http_err:
        return {"error": f"HTTP error occurred: {http_err}"}
    except Exception as err:
        return {"error": f"An unexpected error occurred: {err}"}
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(json.dumps({"error": "No text provided. Use: python scan_text.py <text_file_path>"}))
        sys.exit(1)
    file_path = sys.argv[1]
    if not os.path.exists(file_path):
        print(json.dumps({"error": f"File not found: {file_path}"}))
        sys.exit(1)
    with open(file_path, "r", encoding="utf-8") as f:
        text_content = f.read()
    result = scan_text(text_content)
    print(json.dumps(result, indent=2))

This Python script is invoked directly by the Hermes skill executor. When running the agent inside an enterprise content pipeline, local execution scripts face durability limits. Placing scanned outputs, versioned drafts, and validation reports into a shared repository like Fast.io ensures they are durable and visible to the human editors.

Make sure to install the requests package using the Python package manager:

pip install requests

By keeping the script separated from the core agent loop, you can test it independently using the command line before deploying it.

While local directories or plain S3 buckets store files, they lack version tracking, structural extraction, or a human review layer. Fast.io serves as the persistent database and shared workspace for Hermes deployments. When Hermes Agent runs, it is designed to write its drafts and scanning results back to an environment where human team members can access them.

Fast.io provides several features that enhance the AI detection workflow:

For metadata tracking, Fast.io offers Metadata Views. Instead of writing separate code to track AI detection scores across dozens of files, you can use Metadata Views. This feature acts as a structured extraction layer that turns documents into a live, database view. By defining the fields you want extracted in natural language (such as "extract the AI probability score from the text"), Fast.io designs a typed schema and populates a spreadsheet grid. This allows you to easily track and filter documents by their AI content scores. Learn more at Metadata Views.

For tracking edits, Fast.io preserves a complete per-file version history, making it easy to track changes across multiple agent edits. If an edit worsens the structure, you can restore prior versions instantly.

For real-time collaboration, agents and humans can work side-by-side inside Collaborative Notes. The agent can write its analysis, insert the QuillBot detection reports directly into the notes, and tag human editors for review.

By using Fast.io as the persistent storage backend, the Hermes Agent can use the Fast.io API or the Model Context Protocol (MCP) server to read the content, execute the custom QuillBot skill, and update the document metadata. Fast.io exposes Streamable HTTP at the MCP server and legacy SSE at /sse. This allows Hermes Agent to connect to the MCP server using standard Model Context Protocol tooling. Read the MCP server documentation to set up connection configurations.

To configure your agent to read your storage options directly, visit Fast.io's LLMs directory for agent onboarding instructions.

Fast.io offers three subscription plans on the pricing page: Starter at $29 per month ($24 if billed annually), Business at $99 per month ($83 if billed annually), and Growth at $299 per month ($249 if billed annually). Every organization begins with a 14-day trial that requires a credit card to activate. This trial allows teams to test the workspace storage for agents, workspace features, MCP configurations, and structured metadata views before committing to a paid plan.

Automate content verification inside persistent workspaces

Create a centralized workspace with a Model Context Protocol endpoint for your agent's reads and writes, complete with version history, semantic search, and metadata views. Starts with a 14-day trial.

Start 14-Day Trial

A custom skill is only half the solution; a production workflow requires automated validation. Fast.io features a complete workflow engine equipped with a visual DAG builder, triggers, and approvals. Rather than forcing the agent to constantly poll for changes, you can use webhooks to build reactive pipelines.

To configure the webhook in Fast.io, navigate to your workspace settings and select the Webhooks tab. Register a webhook URL pointing to your Hermes Agent gateway (for instance, a FastAPI endpoint running on your server). You can configure the webhook to trigger on specific events, such as when a file is created, updated, or when a workflow state changes. When an event fires, Fast.io sends a JSON payload containing the file ID, path, and event details to the agent.

For instance, when a human writer or a subagent uploads a new draft to a shared workspace, a webhook triggers the Hermes Agent. The agent downloads the file using standard workspace storage tools, executes the quillbot_detector skill, and checks the score.

If the QuillBot AI percentage exceeds a specific threshold (e.g., 50%), the Fast.io workflow engine halts the publishing process. The DAG builder routes the document to the organization's editor-in-chief, creating a task on their dashboard with a request for approval. If the score is low (e.g., under 10%), the workflow executes a dry-run check and automatically moves the draft to the 'Approved' folder.

If you have complex multi-document campaigns, you can instruct Hermes to spawn isolated subagents. Each subagent can be assigned to verify a specific subdirectory within the Fast.io workspace. This prevents file access conflicts and allows parallel processing of massive content databases.

Once the editing and scanning cycles are complete, the agent can perform an ownership transfer. This moves the organization-owned workspace from the developer or agent account to the business owner, ensuring all version history, metadata views, and audit logs remain secured within the organization's control.

When connecting a self-hosted agent like Hermes to QuillBot, developers must manage API rate limits and structural constraints. Because QuillBot's AI Detector restricts free scans to 1,200 words per request, scanning long-form essays or marketing campaigns requires chunking.

If the input document exceeds 1,200 words, configure the Python execution script to divide the text into paragraphs or sentences, keeping each block under the limit. The script should run parallel requests, average the results, and return a weighted average as the document's total AI percentage.

AI detectors are sensitive to clean text formatting. Scanned PDFs or images may contain extra characters, line breaks, or extraction noise that skews perplexity calculations. Before sending the text to the detection endpoint, use Python standard libraries or regex to clean up the content, remove HTML markup, and normalize spacing. This step minimizes false positive rates and ensures consistent classification scores.

Another common issue is API gateway rate limiting. Unofficial endpoints or third-party wrappers can drop connections during peak traffic times. Implementing exponential backoff in your Python code ensures that the Hermes Agent retries failed requests before flagging a timeout error to the workspace logs. The append-only audit log in Fast.io captures these errors and execution reports, keeping the developer informed without cluttering the main content workspace.

The audit log in Fast.io records every API action, file read, and metadata change. If the custom skill encounters an API timeout, the agent writes the error to the file activity stream. Human team members can audit this log directly from the Fast.io dashboard, making it easy to identify when a RapidAPI key has expired or when the request volume has exceeded the subscription tier.