# What Is the Output of Humanizer in Embedded Mode?

> Discover Humanizer's embedded mode output. Learn how Humanizer returns only the rewritten text, suppressing auxiliary information for cleaner integration.

- Repository: [Siqi Chen/humanizer](https://github.com/blader/humanizer)
- Tags: how-to-guide
- Published: 2026-09-07

---

**In embedded mode, Humanizer returns only the final rewritten text with all auxiliary information suppressed.**

Humanizer is an AI‑text‑editing skill that rewrites machine‑generated prose into natural, human‑sounding language. When invoked in **embedded mode**, it strips away metadata such as detected patterns, drafting steps, and explanatory summaries—producing clean output ready for downstream consumption. This mode is designed specifically for automation pipelines where another task needs the edited text alone.

## How Embedded Mode Works

According to the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) definition in the **blader/humanizer** repository, embedded mode serves "when another task uses this skill for a pull request, commit message, or document." The skill definition explicitly states: *"return only the final text."* This makes embedded mode distinct from the default **pasted text** mode (which includes formatting and context) and **file mode** (which writes to disk).

The embedded mode behavior is defined at line 52 of [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), where the three output styles are documented:

- **Pasted text** (default): Returns formatted output with surrounding context
- **File mode**: Writes the result to a specified file path
- **Embedded mode**: Returns **only the final edited text** as plain prose

## Invoking Embedded Mode: Three Methods

The repository provides three entry points that support embedded mode activation.

### OpenAI‑Compatible Agent Configuration

The [`agents/openai.yaml`](https://github.com/blader/humanizer/blob/main/agents/openai.yaml) file implements conditional output based on the `embedded` flag:

```yaml
name: humanizer
description: Rewrite AI‑sounding text.
prompt: |
  {{#if embedded}}
  {{humanized_text}}
  {{else}}
  {{default_output}}
  {{/if}}

```

When `embedded` is set to `true`, the template renders only `{{humanized_text}}`—the final rewrite with no wrapper content.

### Claude Plugin Manifest

The [`.claude-plugin/plugin.json`](https://github.com/blader/humanizer/blob/main/.claude-plugin/plugin.json) file exposes embedded mode through an option parameter:

```json
{
  "name": "humanizer",
  "description": "Humanizer skill",
  "entrypoint": "SKILL.md",
  "options": {
    "mode": "embedded"
  }
}

```

Setting `"mode": "embedded"` configures the Claude plugin to emit the cleaned, final text directly.

### Programmatic Invocation

The [`scripts/validate-package.py`](https://github.com/blader/humanizer/blob/main/scripts/validate-package.py) file demonstrates loading and calling the skill with mode selection:

```python
from humanizer import Humanizer

skill = Humanizer()
result = skill.apply(text, mode="embedded")
print(result)          # <-- prints only the edited text

```

The `mode="embedded"` keyword argument triggers the suppression logic, ensuring `result` contains exactly the rewritten string.

## What Gets Suppressed in Embedded Mode

To understand the value of embedded mode, consider what is **excluded** from the output:

| Element | Default Mode | Embedded Mode |
|---------|-----------|---------------|
| Final edited text | ✅ Included | ✅ Included |
| Detected AI patterns list | ✅ Included | ❌ Suppressed |
| Step‑by‑step drafting notes | ✅ Included | ❌ Suppressed |
| Explanatory summary | ✅ Included | ❌ Suppressed |
| Formatting markers | ✅ Included | ❌ Suppressed |

This makes embedded mode ideal for **composable workflows** where Humanizer's output becomes input to another system—such as populating pull request templates, generating commit messages, or feeding into documentation generators.

## When to Use Embedded Mode

Choose embedded mode in these scenarios:

- **Pull request automation**: Injecting humanized descriptions into GitHub PR templates
- **Commit message generation**: Producing clean messages for `git commit`
- **Documentation pipelines**: Embedding rewritten text into larger markdown files
- **API responses**: Returning processed text to calling services without wrapper content

Avoid embedded mode when you need visibility into **why** changes were made or when debugging the rewriting process.

## Summary

- **Embedded mode output**: Only the final, rewritten plain text
- **Key source file**: [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) defines the behavior at line 52
- **Activation methods**: [`agents/openai.yaml`](https://github.com/blader/humanizer/blob/main/agents/openai.yaml) flag, [`.claude-plugin/plugin.json`](https://github.com/blader/humanizer/blob/main/.claude-plugin/plugin.json) option, or `mode="embedded"` in Python
- **Use case**: Integration with downstream automation tasks requiring clean prose

## Frequently Asked Questions

### Does embedded mode affect how Humanizer rewrites the text?

No. The rewriting logic remains identical across all modes. Embedded mode only changes **what is returned**—suppressing metadata, not altering the text transformation itself.

### Can I switch modes without modifying configuration files?

Yes. When using the Python API directly, pass `mode="embedded"` to `skill.apply()`. For agent configurations, set the `embedded` template variable to `true` at invocation time.

### Is embedded mode the same as file mode?

No. **File mode** writes output to a specified path on disk and may include metadata in a header. **Embedded mode** returns only the final text to the caller, with no file I/O or additional structure.

### What happens if I call Humanizer without specifying a mode?

The skill defaults to **pasted text** mode, which includes formatting, detected patterns, and explanatory context surrounding the final rewrite.