AI가 생성한 산문을 사람이 작성한 것처럼 다시 작성하는 오픈 소스 모델 컨텍스트 프로토콜(MCP) 서버로, 탐지기가 잘못 판단하는 작가들을 위한 최고 수준의 지원을 제공합니다.
스탠퍼드 연구진이 영어를 모국어로 하지 않는 사람들이 작성한 TOEFL 에세이를 대상으로 7개의 주요 AI 탐지기를 테스트한 결과, 61.3%가 AI 생성물로 분류되었습니다. 같은 종류의 에세이를 작성한 미국 8학년 학생들은 올바르게 분류되었습니다. Patterns(Cell Press, 2023)에 발표된 이 단일 결과가 바로 이 프로젝트가 존재하는 이유입니다.
탐지기가 "AI"라고 부르는 동일한 통계적 특징은 다음의 특징이기도 합니다:
신경다양성 작가, 특히 자폐 성인. 이들의 산문은 어휘 다양성이 낮고 구체적인 어휘를 사용하며 반복적인 구문 구조를 띠는 경향이 있습니다.
ESL(제2언어로서의 영어) 작가. 교과서에서 배운 문법을 사용하여 부자연스러울 정도로 규칙적인 글을 씁니다.
공식 학문 분야의 학자. 이들의 문체는 설계상 균일하고 담화 표지가 밀집되어 있습니다.
2026년 Springer 연구에 따르면 학술적 글쓰기에 대한 Originality.ai의 실제 오탐률은 14%로, 회사가 밝힌 비율보다 10배나 높았습니다. 2026년 ZeroGPT에 대한 독립적인 테스트에서는 학생 에세이의 26.4%, ESL 작가의 글에서 21% 이상의 오탐률이 측정되었습니다.
이러한 탐지기들은 학계, 고용, 출판 및 비자 심사 워크플로우에 배치되어 있습니다. HumanizeMCP는 상용 휴머나이저(humanizer)가 제공하는 폐쇄형 휴리스틱이 아닌, 동료 검토를 거친 회피 문헌을 기반으로 구축되어 영향을 받는 작가들에게 자신을 방어할 수 있는 도구를 제공합니다.
전체 증거 기반은 research/에 있습니다. 합법적인 접근성 사용과 학문적 부정행위 사이의 경계에 대해서는 docs/ETHICS.md를 읽어보십시오.
Related MCP server: originality-mcp
HumanizeMCP는 모델 컨텍스트 프로토콜(Model Context Protocol) 서버입니다. MCP를 지원하는 모든 클라이언트(Claude Code, GitHub Copilot CLI, Continue, Zed, Cursor 등)에서 도구를 호출할 수 있습니다. 로컬에서 실행되며 원격 측정을 수행하지 않고, 첫 실행 시 선택적인 Hugging Face 모델 다운로드를 제외하고는 네트워크 호출을 하지 않습니다.
핵심 기능:
research/06_implementation_recommendations.md의 설계를 따르는 9단계 파이프라인(전처리, 표면적 특징 대체, 워터마크 제거, 문체 평활화, 제어된 의역, 탐지기 기반 반복, 선택적 역번역, 음성 보존, 검증).
호출별로 구성 가능한 문체 프리셋(casual, blog, academic, esl, neurodivergent, preserve 등).
오픈 모델(RoBERTa-OpenAI-detector, Fast-DetectGPT, Binoculars)에 대한 로컬 탐지기 벤치마킹 및 사용자가 자신의 키를 제공할 경우 상용 API를 위한 선택적 어댑터.
대상 탐지기 점수에 도달하거나 예산이 소진될 때까지 재휴머나이즈하는 검증 및 반복 루프(humanize_and_verify).
# Using uv (recommended)
uv venv
source .venv/bin/activate
uv pip install -e .
# Or with pip
python -m venv .venv
source .venv/bin/activate
pip install -e .Hugging Face 모델을 사용하는 첫 번째 호출 시 ~/.cache/huggingface/에 가중치가 다운로드됩니다. 기본 탐지기(roberta-base-openai-detector)는 약 500MB입니다.
Claude Code (~/.config/claude-code/mcp.json 또는 동등한 파일):
{
"mcpServers": {
"humanize": {
"command": "humanize-mcp"
}
}
}GitHub Copilot CLI (~/.copilot/mcp-config.json):
{
"mcpServers": {
"humanize": {
"command": "humanize-mcp"
}
}
}virtualenv에 설치한 경우 command를 스크립트의 절대 경로(/path/to/.venv/bin/humanize-mcp)로 지정하십시오.
MCP 클라이언트에서:
> use humanize on the following text with style="academic":
>
> In this paper, we delve into the multifaceted intricacies of consensus
> mechanisms — leveraging robust theoretical frameworks to underscore the
> pivotal role of decentralized governance in fostering trust.서버는 delve 클러스터를 제거하고, 대시를 끊고, 문장 길이를 다양화하며, ( humanize_and_verify가 사용된 경우) 재작성된 글이 요청된 AI 임계값 미만임을 로컬 탐지기로 확인한 결과를 반환합니다.
모든 도구는 MCP로 호출 가능합니다. 타입 시그니처는 Pydantic에 의해 강제됩니다.
humanize(text, style="default", preserve_voice=True, intensity=0.7) -> strtext에 대해 전체 휴머나이제이션 파이프라인을 실행합니다. intensity는 [0, 1] 범위이며 연구 문서의 최소/균형/공격적 레버에 매핑됩니다.
humanize(
text="The implementation leverages a robust framework...",
style="academic",
preserve_voice=True,
intensity=0.7,
)
# -> "The implementation uses a sturdy framework..."detect_tells(text) -> TellsReport재작성 없이 AI의 흔적을 찾습니다. 줄 번호, 문자 오프셋, 심각도(research/02_ai_tells_catalog.md와 일치하는 별 1-5개) 및 대체 제안을 반환합니다.
detect_tells("We delve into the intricate tapestry of...")
# -> TellsReport(
# tell_count=3,
# tells=[TellLocation(category="excess_vocabulary", fragment="delve",
# line=1, char_start=3, char_end=8, severity=5,
# suggestion="examine"),
# ...],
# summary={"excess_vocabulary": 3},
# )score_humanity(text, detectors=["roberta-base"]) -> HumanityReport하나 이상의 로컬 탐지기를 실행하고 탐지기별 확률과 종합 결과를 반환합니다. 판정 결과는 "human", "uncertain", "ai", "unknown" 중 하나입니다.
score_humanity(text, detectors=["roberta-base", "fast_detect_gpt"])
# -> HumanityReport(
# detector_scores=[DetectorScore(detector="roberta-base",
# probability_ai=0.87, ...),
# DetectorScore(detector="fast_detect_gpt",
# probability_ai=0.91, ...)],
# aggregate_probability_ai=0.89,
# verdict="ai",
# )apply_style(text, style) -> str순수한 문체 변환이며 휴머나이제이션은 수행하지 않습니다. AI 흔적을 건드리지 않고 학술적 문체를 블로그 문체로 바꾸거나 격식 있는 문체를 캐주얼하게 바꿀 때 유용합니다.
list_styles() -> list[str]styles/에 현재 등록된 문체 프리셋을 나열합니다.
humanize_and_verify(text, style="default", target_ai_score=0.3, max_iterations=3) -> VerifyResult휴머나이즈하고 점수를 매긴 뒤, 점수가 목표치보다 높으면 더 높은 강도로 재휴머나이즈하는 과정을 목표치에 도달하거나 max_iterations에 도달할 때까지 반복합니다. 최종 텍스트와 함께 전/후 점수 및 반복별 로그를 반환합니다.
result = humanize_and_verify(text, target_ai_score=0.2, max_iterations=5)
print(result.final_score.aggregate_probability_ai) # e.g. 0.18
print(result.target_reached) # Truestyles/에 정의되어 있습니다. 프로젝트가 성숙해짐에 따라 세트가 진화하므로, 실시간 목록은 list_styles()를 호출하십시오. MVP는 다음을 제공합니다:
프리셋 | 용도 | 참고 |
| 범용 재작성 | 균형 잡힌 강도, 보수적인 음성 보존 |
| 개인 이메일, 소셜 게시물 | 격식 제거, 버스트성(burstiness) 향상 |
| 긴 형식의 개인 글쓰기 | 문단 리듬 유지 |
| 학회 논문, 학위 논문 | 담화 표지 보존, |
| L2 영어 작가 | 더 단순한 구문 보존, 탐지기에 걸리는 표면적 흔적 제거 |
| 자폐/ND 작가 | 반복적인 구문 구조 보존, 낮은 어휘 다양성 유지 |
| "내 목소리를 바꾸지 마" | 표면적 흔적만 수정, 의역 단계 없음 |
프리셋 스키마와 자신만의 프리셋을 추가하는 방법은 docs/ARCHITECTURE.md에 문서화되어 있습니다.
+------------------------+
| MCP Client (Claude |
| Code, Copilot, ...) |
+-----------+------------+
| stdio (MCP)
v
+------------------------+
| server.py (FastMCP) | <-- this package
+-----+-----+-----+------+
| | |
v v v
+--------+ +--------+ +----------+
| pipe- | | styles | | bench- |
| lines/ | | | | mark/ |
+--------+ +--------+ +----------+
| |
v v
+----------------------------+
| 9-pass pipeline: |
| 1. preprocess |
| 2. surface tells |
| 3. watermark scrub |
| 4. stylometric smoothing |
| 5. DIPPER paraphrase |
| 6. detector-guided loop |
| 7. back-translation (opt) |
| 8. style transfer |
| 9. verification |
+----------------------------+전체 아키텍처 및 확장 지점: docs/ARCHITECTURE.md.
벤치마크 하네스는 benchmark/에 있으며 현재 구축 중입니다. 아래의 헤드라인 수치는 벤치마크 엔지니어가 RAID 테스트 세트에서 측정한 값으로 대체할 자리 표시자입니다.
탐지기 | 휴머나이제이션 전 (평균 P(AI)) | 휴머나이제이션 후 (평균 P(AI)) | 감소율 |
RoBERTa-OpenAI | TBD | TBD | TBD |
Fast-DetectGPT | TBD | TBD | TBD |
Binoculars | TBD | TBD | TBD |
GPTZero (API) | TBD | TBD | TBD |
Originality.ai (API) | TBD | TBD | TBD |
로컬에서 재현:
python -m benchmark.run --dataset raid_subset --pipeline default이 도구는 다음과 같은 합법적인 접근성 및 형평성 사용을 위해 구축되고 문서화되었습니다:
자신의 글이 잘못 분류되고 있는 신경다양성 작가.
해당 집단에 대해 21-61%의 오탐률이 독립적으로 측정된 도구에 의해 학술 제출물이 플래그 지정되는 ESL 작가.
기관의 워크플로우에 배치되어서는 안 될 취약한 탐지기를 트리거하는 공식 학문 분야의 산문을 작성하는 학자.
탐지기 기반의 플랫폼 퇴출을 피하려는 언론인이나 에세이스트.
이 도구는 다음을 위해 구축되지 않았으며, 유지 관리자는 다음을 지원하지 않습니다:
독창적인 저작물을 요구하는 학점 학업 과제에서 LLM이 생성한 결과물을 자신의 글인 것처럼 제출하는 행위.
허위 정보, 스팸 또는 대규모로 기만하도록 설계된 콘텐츠 생성.
안전이 중요한 상황(의료 조언, 법률 서류, 보안 관련 공개)에서 탐지기를 무력화하는 행위.
기술적 파이프라인은 두 집단을 동일하게 지원하며, 이는 피할 수 없는 부분입니다. 이는 Tor, Signal 및 지금까지 존재해 온 모든 의역 도구가 취하는 윤리적 입장과 동일합니다. 전체 성명은 docs/ETHICS.md에서 읽어보십시오.
우리는 동형 문자 공격, 폐쇄형 모델을 위한 워터마크 제거, 너비가 0인 문자 삽입 또는 스크린 리더와 같은 접근성 도구를 손상시키는 어떠한 기술도 제공하지 않습니다. 그것들은 휴머나이제이션이 아니라 익스플로잇(악용)입니다.
연구에서 HumanizeMCP를 사용하는 경우, 문서와 프로젝트를 인용해 주십시오:
@software{humanize_mcp_2026,
author = {Olivas, Kit},
title = {HumanizeMCP: an open-source MCP server for accessibility-first
AI-text humanization},
year = {2026},
url = {https://github.com/kitfoxs/humanize-mcp},
version = {0.1.0},
note = {Research dossier in research/, evidence base in
research/references.bib}
}research/에 있는 연구 문서는 그 자체로 인용 가능한 문서이며 이 프로젝트가 기반으로 하는 동료 검토 작업의 전체 참고 문헌을 포함하고 있습니다.
MIT. LICENSE를 참조하십시오.
Kit Olivas(@kitfoxs)와 Ada Marie가 제작했습니다.
연구 문서는 Liang et al.(Stanford, 2023), Dugan et al.(RAID, 2024), Krishna et al.(DIPPER, 2023), Cheng et al.(Adversarial Paraphrasing, 2025), David & Gervais(AuthorMist, 2025), Kobak et al.(어휘 변화 연구, 2024), Juzek & Ward(초점 단어 분석, 2024) 등의 연구를 참고했습니다. 전체 인용은 research/references.bib에 있습니다.
오탐으로 인한 피해를 공개적으로 알린 작가, 학생, 학자분들께 특별한 감사를 드립니다.
Apply a style preset to text without running humanization passes.
Useful when the caller wants pure register translation (formal to
casual, academic to blog, etc.) without removing AI tells. The set
of legal style names is whatever :func:list_styles returns.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The input prose. | |
| style | Yes | Name of a style preset registered in ``styles/``. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It clearly discloses that this tool does NOT humanize and performs only style/register transformation. It could add details about side effects or atomicity, but for a text-transform tool the key behavioral trait is well covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact: a single lead sentence stating core action and exclusions, followed by a brief usage context. No redundant wording exists.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple parameter set (text, style), output schema existence, and sibling context, the description fully covers what the tool does, when to use it, and how to obtain valid style values. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds value beyond the schema by clarifying that 'style' is a registered preset (from list_styles) and providing examples of register translation. This supplements the schema's generic type/description information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Apply') and resource ('style preset to text') and clearly distinguishes itself from siblings by stating 'without running humanization passes.' This makes its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Useful when the caller wants pure register translation... without removing AI tells.' It also points to list_styles for legal style names, providing clear guidance on prerequisites and differentiation from humanization tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Locate AI writing tells in the input text.
Reports surface signatures catalogued in
research/02_ai_tells_catalog.md: excess vocabulary (the "delve"
cluster), em-dash overuse, sentence-initial discourse markers,
copular templates, conversational scaffolding, and parallel-structure
overuse. Each tell carries a 1-indexed line number, character offsets,
a 1-to-5 severity, and an optional substitution suggestion.
The intended use is diagnostic: surface what would be edited by
:func:humanize so a writer can decide which tells to preserve and
which to remove.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The input prose to scan. |
| Name | Required | Description |
|---|---|---|
| tells | Yes | |
| summary | No | Count of tells per category. |
| tell_count | Yes | |
| text_length | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It details what the tool reports (specific signature categories) and the output structure (line number, offsets, severity, substitution), plus its diagnostic role. It does not mention read-only nature or error handling, but the scanning behavior is well defined.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded, with the core action in the first sentence. The subsequent sentences add concrete detail about signature types, returned fields, and intended use without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter detection tool with an output schema, the description is thorough: it states the purpose, lists detection categories, describes the output fields, and explains why a writer would use it. Some limitations (e.g., input length, language) are omitted, but they are minor and the overall context is clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes the single parameter 'text' as 'The input prose to scan' (100% coverage). The description adds minimal extra parameter meaning, only reinforcing that it scans prose. Therefore it meets the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb 'Locate' and a clear resource 'AI writing tells in the input text', then enumerates concrete tell categories and output fields. This clearly distinguishes it from sibling tools like humanize (which edits) by framing itself as diagnostic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the intended use: 'diagnostic: surface what would be edited by humanize so a writer can decide which tells to preserve and which to remove.' This tells the agent when to use it (before humanize) and expresses a clear alternative (humanize) but does not explicitly address all sibling tools like score_humanity, which might also be diagnostic.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Rewrite AI-generated text so it reads as human-authored.
Runs the configured pipeline of passes (preprocess, surface-tell
substitution, watermark scrub, stylometric smoothing, optional
paraphrase passes; see docs/ARCHITECTURE.md) and returns the final
text. For diagnostic output (per-pass diff, before/after detector
scores) use :func:humanize_and_verify instead.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The input prose to humanize. Markdown formatting is tolerated and normalized in the preprocess pass. | |
| style | No | Name of a style preset registered in ``styles/``. Common presets include ``"casual"``, ``"blog"``, ``"academic"``, ``"esl"``, ``"neurodivergent"``, ``"preserve"``. Use :func:`list_styles` to enumerate what is actually available at runtime. | default |
| intensity | No | Continuous control in [0, 1] mapping to the ``minimal`` / ``balanced`` / ``aggressive`` levers documented in the research dossier. Roughly: 0.0-0.33 minimal, 0.34-0.66 balanced, 0.67-1.0 aggressive. Higher values run more passes and apply heavier per-pass edits. | |
| preserve_voice | No | When True, the pipeline retains identifying stylistic features the author would want to keep (sentence-length distribution, lexical idiom, characteristic punctuation). When False, the pipeline is free to flatten voice in pursuit of detector evasion. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the internal pipeline (preprocess, surface-tell substitution, watermark scrub, stylometric smoothing, optional paraphrase passes), which is valuable behavioral context. It does not explicitly state whether the tool is read-only or has side effects, but for a text transformation tool this is largely implicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: a one-sentence purpose, one sentence on process, and one sentence pointing to an alternative. Every sentence adds value with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (configurable pipeline) and rich schema/output schema, the description is complete enough for selection. It explains the purpose, distinguishes from the diagnostic variant, and provides a pointer to further architecture docs without over-explaining return values already covered by the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description itself does not add substantial parameter meaning beyond the schema; it references docs and list_styles but repeats concepts already covered in the schema's property descriptions. Thus it does not exceed the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource+outcome: 'Rewrite AI-generated text so it reads as human-authored.' It distinguishes itself from sibling humanize_and_verify by explicitly noting that the latter provides diagnostic output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly tells when to use this tool vs the alternative: use humanize for the final text, and humanize_and_verify for diagnostic output. It also points to list_styles for enumerating available style presets, giving practical usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Humanize, then iterate against detectors until a target score is met.
v0.2.0 (Bet 3): wraps :class:pipelines.IterativeHumanizer, which
implements the Cheng et al. 2025 detector-guided loop (research/04
section 1.3). Each iteration:
Locates the worst-scoring paragraph in the current text.
Generates candidates_per_iteration stochastic paraphrase
candidates of that paragraph (via ParaphrasePass.paraphrase_candidates).
Scores each candidate, keeps the lowest, splices it back in.
Re-scores the whole text. If at or below target_ai_score, returns.
This replaces the v0.1.0 loop, which re-ran the deterministic 9-pass
pipeline at ramped intensities. As documented in
docs/REVIEW_v0.1.0.md section 2.9, every pass except 9-heavy is
idempotent on its own output, so iterations 2-3 of the old loop did no
work. The new loop is meaningfully different because it depends on
stochastic candidate generation: only non-deterministic search can
converge on a lower score after a deterministic fixed point.
The function always returns a result, even if the target was not
reached; callers should check target_reached to know.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The input prose to humanize. | |
| style | No | Name of a style preset; see :func:`list_styles`. | blog |
| max_iterations | No | Hard upper bound on improvement iterations. Must be >= 1. Iteration 0 is always the baseline humanization and does not count against this bound. | |
| target_ai_score | No | The aggregate probability_ai value below which the loop exits. Must be in [0, 1]. Cheng et al. 2025 use 0.15 as their stop value; we keep 0.3 ("comfortably human") as the default for backwards compatibility with v0.1.x callers. | |
| target_detector | No | Which detector field the loop optimizes against. ``"trusted_mean"`` (default) uses the suite's mean over detectors without documented bias caveats. ``"raw_mean"`` uses the unweighted mean across all detectors. Any other value is treated as a specific detector name (e.g. ``"roberta_openai"``). | trusted_mean |
| candidates_per_iteration | No | How many stochastic paraphrase candidates to generate per iteration. The Cheng et al. 2025 paper uses 3-5; we default to 3 as a quality / latency tradeoff. Must be >= 1. |
| Name | Required | Description |
|---|---|---|
| text | Yes | |
| notes | No | |
| iterations | Yes | |
| final_score | Yes | The full output of :func:`score_humanity`. |
| initial_score | Yes | The full output of :func:`score_humanity`. |
| total_time_ms | No | Total wall-clock time including baseline humanization. |
| target_reached | Yes | |
| target_ai_score | Yes | |
| target_detector | No | Which detector field the loop optimized against. One of "trusted_mean", "raw_mean", or a specific detector name. |
| per_iteration_scores | No | Whole-text AI probability after iteration 0 (baseline) then after each accepted improvement. Empty if scoring was unavailable. |
| candidates_per_iteration | No | How many stochastic paraphrase candidates were generated per iteration. 1 reduces the loop to deterministic paraphrasing. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden and does well: it explains the stochastic candidate generation, the per-iteration splicing, and the critical behavior that the function always returns a result, requiring the caller to check 'target_reached'. It also discloses the algorithm's reliance on non-determinism to break fixed points, adding meaningful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a one-sentence purpose and uses numbered steps for algorithm clarity. The historical comparison to v0.1.0 adds several sentences, but it serves to explain why the loop is stochastic, which is behaviorally relevant. It is longer than strictly necessary but well-structured and justifiable for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the iterative process, parameter behavior, and return-value expectations (checking 'target_reached'). It does not explicitly contrast with sibling tools, but the tool is complex and the description provides enough detail to understand its role. The presence of an output schema also offloads return-structure details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed descriptions for all six parameters, so the schema already provides defaults, constraints, and semantics. The description does mention 'candidates_per_iteration' and 'target_ai_score' in the loop description, but this adds only illustrative context rather than new parameter meaning beyond the schema's own thorough explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening sentence 'Humanize, then iterate against detectors until a target score is met' clearly specifies the verb (humanize and verify), resource (text), and goal (target score). This distinguishes the tool from siblings like 'humanize' by emphasizing the iterative detector-guided loop rather than a single-pass transformation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for cases where a target AI score must be reached, but it never explicitly states when to prefer this over sibling tools such as 'humanize' or 'score_humanity'. It provides no exclusions or alternative conditions, and the 'always returns a result even if target was not reached' note is more behavioral than usage-oriented.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the names of all currently registered style presets.
Style presets are loaded from the styles/ package. If the package
is unavailable an empty list is returned.
list of str
Sorted list of preset names, e.g. ["academic", "blog", "casual", "esl", "neurodivergent", "preserve"].
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return type (list of str), sorted order, example values, and an edge case (empty list if package unavailable). This gives the agent an accurate expectation of behavior, though it doesn't explicitly state side-effect-free behavior (which is implied by 'list').
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a single purpose line, a brief source/edge-case note, and a Returns section with type and example. Every sentence adds value without unnecessary fluff, and the formatting is clean.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, parameter-less listing tool with an output schema, the description is complete. It explains what is returned, the ordering, a representative example, and what happens if the package is unavailable. No critical information is missing for the agent to effectively invoke and use this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is an empty object. The description adds no parameter details, but none are needed. The baseline for a zero-parameter tool is 4, and the description provides relevant return-value context that compensates adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List the names of all currently registered style presets.' This uses a specific verb (list) and resource (style presets), distinguishing it from siblings like apply_style or humanize. It also adds context about the source package and an example output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by explaining the purpose (listing preset names) and the behavior when the package is unavailable. While it doesn't explicitly mention alternatives or when not to use it, the intended use as a lookup tool is evident. The absence of explicit exclusions is acceptable for such a simple read-only operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Score how AI-like the text reads to one or more open detectors.
Wraps the local detector adapters in benchmark/. The default
detector list is ["roberta-base"] (the canonical academic
baseline; see research/01_detector_landscape.md). Other adapters
such as "fast_detect_gpt" and "binoculars" are added as the
benchmark package matures.
Aggregate probability is the arithmetic mean of detector scores that
returned successfully. If every detector failed, aggregate is
-1.0 and the verdict is "unknown".
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The input prose to score. | |
| detectors | No | Names of detector adapters to run. Defaults to ``["roberta-base"]`` if not given or empty. |
| Name | Required | Description |
|---|---|---|
| verdict | Yes | One of "human", "uncertain", "ai", or "unknown". |
| text_length | Yes | |
| detector_scores | Yes | |
| aggregate_probability_ai | Yes | Mean of successful detector probability_ai scores. Equals -1.0 if no detector returned a score. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for disclosure. It explains key behaviors: aggregate probability as arithmetic mean, failure handling (if every detector fails, aggregate is -1.0 and verdict is 'unknown'), and the default detector list. This goes beyond the schema and gives the agent a solid understanding of expected outcomes and edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a clear one-sentence purpose, followed by concise details on defaults, adapter examples, and aggregate behavior. Every sentence earns its place without unnecessary fluff. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, parameters, default behavior, and edge-case output. Since an output schema exists, the return structure is already defined, but the description adds crucial context about the aggregate value and verdict string. For a tool with 2 parameters and moderate complexity, this is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds meaningful context. It clarifies the 'detectors' parameter with the default value, the empty-list behavior, and examples of allowed adapter names. The description also explains how outputs are aggregated, which is directly relevant to interpreting the parameters. This significantly enriches the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Score how AI-like the text reads to one or more open detectors.' This clearly states the tool's function and distinguishes it from siblings like humanize (which transforms text) and detect_tells (which likely identifies tells). The reference to detectors also sets it apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for scoring AI-likeness but does not explicitly state when to prefer this over alternatives. It mentions the default detector list and adapters, giving context about configuration, but it does not contrast with sibling tools or provide exclusion criteria. Usage guidance is clear enough for a scoring tool but not explicitly framed as 'use when...'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0apply_styledetect_tellshumanizehumanize_and_verifylist_stylesscore_humanityScored across 6 tools
Most tools are clearly distinct: detect_tells, score_humanity, apply_style, and list_styles each serve unique purposes. The only potential confusion is between humanize and humanize_and_verify, but their descriptions clearly delineate the simple pipeline from the iterative verification loop, so agents should be able to choose correctly.
All tool names follow a consistent verb_noun pattern: humanize, detect_tells, score_humanity, apply_style, list_styles, humanize_and_verify. Even the compound name follows the convention. No mixing of styles or vague verbs.
Six tools is well-scoped for a text humanization server. Each tool covers a distinct aspect: core humanization, diagnostic analysis, scoring, style control, and verification loop. This is an appropriate size without redundancy or bloat.
The toolset provides complete coverage of the humanization workflow: humanize for direct rewriting, humanize_and_verify for iterative improvement, detect_tells for diagnostics, score_humanity for evaluation, and apply_style/list_styles for style manipulation. There are no obvious gaps in the lifecycle.
An MCP server that integrates with Discord to provide AI-powered features.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Walter Remote MCP Server — AI humanization and detection tools
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
