How to Build a Hermes Agent QuillBot AI Detector Workflow

A peer-reviewed Stanford University study published in the journal Patterns found that popular AI detectors misclassified over 61% of essays written by non-native English speakers as AI-generated. The researchers demonstrated that these verification tools rely on linguistic predictability, disproportionately penalizing writers who use standard vocabulary and simple sentence structures. This high error rate highlights a major operational challenge for modern content teams. If your publication relies on raw AI content checkers, you risk rejecting clean, human-written drafts or publishing robotic prose. To resolve this problem, developers are building automated loops using open-source tools. A Hermes Agent QuillBot workflow is an automated pipeline where an agent generates draft content, submits it to QuillBot's checker, analyzes the report, and commits the humanized version to a shared workspace.

This guide explains how to construct this automated pipeline using the Nous Research Hermes Agent. By writing a custom browser automation skill, you can pass text drafts through the verification process and parse the results programmatically. This removes the manual bottleneck of copying and pasting text blocks into web interfaces. Additionally, we cover how to save the audited drafts in a versioned, secure team environment.

The automated workflow follows a clear four-step process:

1. Drafting: The Hermes Agent generates the initial draft content.

2. Checking: The agent automates QuillBot's AI content detector using a custom Playwright-based skill to calculate the AI likelihood score.

3. Humanizing: If the text flags as AI-generated, the agent refines it iteratively until the score drops below the target threshold.

4. Uploading: The finalized, human-grade draft is uploaded to a shared Fastio workspace, tracking its metadata via a Fastio Metadata View.

Nous Research Hermes Agent is an open-source, developer-focused assistant released under the MIT license. It runs as a persistent process on local servers, Docker containers, or remote instances like Modal or Singularity. Unlike hosted software-as-a-service platforms, it gives developers direct control over how the model runs scripts, communicates with API endpoints, and manages files. One of the main advantages of this agent is its modular architecture, which supports the agentskills.io standard. This standard allows you to write custom instructions and code helpers that the agent loads dynamically when executing a task.

The official Nous Research Hermes Agent documentation does not include built-in support for QuillBot or third-party AI content checkers. To automate the verification process, you must construct a custom skill. Custom skills are stored in a local directory containing a SKILL.md file and a scripts directory. The agent parses the SKILL.md frontmatter at startup to understand what tools are available and what parameters they require.

When the agent executes the validation task, it needs a stable environment to read context and store outputs. While developers often write temporary files to local directories or raw cloud storage like Amazon S3, these methods lack collaboration features. Local storage is lost when ephemerally hosted containers reboot, and raw object storage does not provide indexing or versioning for team members. Connecting your agent to a Fastio workspace resolves these storage issues, providing a permanent record of all drafts and verification runs.

~/.hermes/skills/
└── quillbot-detector/
    ├── SKILL.md
    └── scripts/
        └── quillbot_check.py

skills:
  external_dirs:
    - "~/.hermes/skills/quillbot-detector"

QuillBot is widely used for paraphrasing, with millions of writers and educators adopting the platform for content verification. Its web-based AI content detector is designed for human interactions, requiring writers to paste text into a browser box. The platform does not offer an official public API for developers. To automate quillbot ai detector checks, you must write a script that replicates this manual interaction. Playwright is a reliable choice for this task, offering headless browser automation that handles dynamic web pages and waits for elements to render.

To implement this automation, we write a Python script that launches a browser, navigates to the detector, fills the input text, submits the form, and parses the resulting score. The script outputs a structured JSON response, which the Hermes Agent reads to determine the next step in the content pipeline.

Below is the complete implementation of the Python helper script. Save this file in the scripts directory of your skill:

import sys
import json
import asyncio
from playwright.async_api import async_playwright

async def check_text(text):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
        )
        page = await context.new_page()
        try:
            await page.goto("https://quillbot.com/ai-content-detector", timeout=30000)
            await page.wait_for_selector("textarea[placeholder*='text']", timeout=10000)
            await page.fill("textarea[placeholder*='text']", text)
            await page.click("button:has-text('Analyze text'), button:has-text('Detect AI')")
            await page.wait_for_selector("[class*='score'], [class*='percentage']", timeout=15000)
            score_element = await page.query_selector("[class*='score'], [class*='percentage']")
            if score_element:
                score_text = await score_element.text_content()
                score_val = score_text.strip()
            else:
                score_val = "0%"
            return {"status": "success", "ai_score": score_val}
        except Exception as e:
            return {"status": "error", "message": str(e)}
        finally:
            await browser.close()

if __name__ == "__main__":
    input_text = sys.stdin.read()
    if not input_text.strip():
        print(json.dumps({"status": "error", "message": "Empty text input"}))
        sys.exit(1)
    result = asyncio.run(check_text(input_text))
    print(json.dumps(result))

---
name: quillbot_detector
description: Runs draft text through QuillBot's AI content detector using browser automation.
version: 1.0.0
---

QuillBot AI Detector Integration
================================

Use this skill when you need to analyze a draft's AI probability score before committing it to a workspace.

Usage Instructions
------------------

1. Pipe the content draft into the Python helper script:
   python scripts/quillbot_check.py < draft.txt

2. The script returns a JSON response containing the status and the ai_score.

3. Parse the ai_score percentage:
   - If the score is below twenty percent, the content is ready for upload.
   - If the score is twenty percent or higher, trigger the rewriting routine to humanize the draft.

Persist refined drafts in an intelligent workspace

Store agent drafts, track AI detector scores, and collaborate with your team in a versioned Fastio workspace. Every organization starts with a 14-day free trial.

Start 14-Day Trial

After retrieving the AI score, the agent needs a persistent location to store the drafts and record the verification metrics. Local directories are too limited for teams, as they do not support concurrent access. Traditional cloud drives and object storage like Google Drive or Amazon S3 lack built-in tools for extracting metadata, forcing teams to write custom databases to track which files have been checked.

Fastio solves these issues by providing shared workspaces with built-in data extraction. Through Metadata Views, you can transform your file storage into a queryable database. Instead of writing custom parsing rules or database queries, you describe the fields you want to extract in natural language. The platform's AI suggests columns with appropriate data types and pulls the information directly from the uploaded files. For this workflow, you can set up a view with fields for the target keyword, the validation status, and the AI probability score.

The Hermes Agent interacts with the workspace using the Model Context Protocol. Fastio exposes a dedicated MCP server via Streamable HTTP at /mcp and legacy SSE at /sse, allowing the agent to read, write, and search files directly. When the agent uploads a draft to the workspace, Fastio auto-indexes the document. This enables hybrid Search, combining exact full-text matching with semantic retrieval. Team members can search by metadata values, such as finding drafts with a low AI detector score, or search by meaning directly from their interface.

Every file uploaded to the workspace has a detailed, per-file version history. When the agent edits a draft during the rewriting loop, Fastio preserves the previous file version. This ensures that the team has an immutable audit trail of all changes. If a rewritten draft loses its original meaning, human editors can easily restore previous versions and track the refinement steps.

To achieve the best results, the hermes agent humanizer workflow combines the speed of autonomous agents with the editing skills of human writers. The agent handles the initial writing, checking, and automated rewriting, while human editors provide the final polish.

This collaboration is built on Fastio Collaborative Notes. Unlike static text documents, Collaborative Notes support real-time, concurrent co-editing. Both human writers and Hermes Agent instances can edit the same note simultaneously, with visible cursors showing where each editor is working. When the agent writes a draft in a note, a human editor can adjust sentences in real time. The agent observes these edits and adapts its style to match, improving the quality of the draft.

Once the draft meets the quality guidelines and passes the checker, the agent manages the handoff. It can create an Exchange share, allowing clients or stakeholders to access the document securely. These shares can be set to expire automatically or restricted to specific recipients, ensuring your drafts are not exposed to the public.

When the workflow is complete, the agent can transfer ownership of the organization to a human client. The agent generates a claim link, allowing the human to take over the workspaces. The human signs up for a free user account, joins the organization, and starts a paid subscription. Fastio offers three plans: Starter at $29 per month ($24 annual), Business at $99 per month ($83 annual), and Growth at $299 per month ($249 annual). Every organization starts with a 14-day free trial that requires a credit card to activate. This trial provides access to workspaces, the MCP server, and Metadata Views, allowing teams to manage their agent workflows with confidence.