# How Embedded Mode Functions in Humanizer: A Complete Guide

> Discover how embedded mode in Humanizer works. This guide explains its function for automated tasks like generating pull request descriptions and commit messages, returning only rewritten text.

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

---

**Embedded mode in Humanizer returns only the final rewritten text without metadata or pattern lists, specifically designed for automation tasks like generating pull request descriptions and commit messages.**

Humanizer is an open-source text processing skill that eliminates AI-generated artifacts from content. While the tool supports multiple output formats, Embedded mode serves a distinct purpose for integration workflows within the `blader/humanizer` repository. This guide explains the technical implementation and practical applications of Embedded mode based on the official source code.

## What Is Embedded Mode?

Humanizer operates in three distinct output styles: **pasted text** (default), **file mode**, and **Embedded mode**. The Embedded variant specifically targets machine-to-machine communication scenarios where downstream systems require clean text without presentation overhead.

Unlike the default mode, which returns auxiliary information such as lists of remaining AI patterns and processing summaries, Embedded mode strips all metadata. This design makes it ideal for CI pipelines, documentation generators, and version control workflows that consume Humanizer's output programmatically.

## How Embedded Mode Functions

### Detection and Context Inference

The skill activates Embedded mode through two distinct mechanisms. First, explicit declaration via the `mode` field set to `embedded` in the incoming JSON payload. Second, implicit inference when the execution context matches specific automation scenarios—namely pull request generation, commit message creation, or document compilation tasks.

The processor evaluates both the payload parameters and the caller environment to determine whether to invoke the Embedded branch of the rewrite logic.

### Output Behavior

When Embedded mode is active, the skill executes the full internal rewrite process—including AI pattern detection and text normalization—but modifies the response structure significantly. Rather than returning a structured object containing metadata, the processor outputs **only the final edited text string**.

This behavior eliminates the need for downstream parsers to extract content from nested JSON fields or filter out explanatory summaries.

## Implementation in the Source Code

The formal definition of Embedded mode resides in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) at lines 52–53:

> **Embedded mode.** When another task uses this skill for a pull request, commit message, or document, return only the final text.

The skill processor implements this specification by checking the incoming request for the `mode` parameter or analyzing the execution context to identify automation callers. When either condition matches, the code path bypasses the metadata assembly stage and returns the raw processed string.

Supporting documentation appears in [`README.md`](https://github.com/blader/humanizer/blob/main/README.md), which explains the three output modes for end-users, and [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md), which catalogs the automation agents capable of loading the Humanizer skill in Embedded contexts.

## Practical Usage Examples

### JSON API Request

To explicitly trigger Embedded mode via direct API invocation:

```json
{
  "skill": "humanizer",
  "mode": "embedded",
  "input": "It’s not just about speed; it’s about reliability. That is the real win."
}

```

The response contains only the processed text without wrapping objects:

```

It’s about reliability, not just speed.

```

### CI Pipeline Integration

When using Humanizer within a GitHub Actions workflow to generate pull request descriptions:

```yaml
steps:
  - name: Run Humanizer
    uses: blader/humanizer@v3
    with:
      mode: embedded
      text: |
        The new API — announced yesterday — improves latency.

```

The pipeline receives the cleaned text directly, suitable for immediate assignment to the PR description field:

```

The new API improves latency.

```

## Summary

- **Embedded mode** returns only the final rewritten text, eliminating all metadata, pattern lists, and explanatory summaries.
- **Activation methods** include explicit `mode: embedded` parameter declaration or automatic inference from automation contexts like PR or commit message generation.
- **Primary implementations** suit CI/CD pipelines, documentation generators, and version control integrations requiring clean text output.
- **Source definitions** are located in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) (lines 52–53), with additional context in [`README.md`](https://github.com/blader/humanizer/blob/main/README.md) and [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md).

## Frequently Asked Questions

### What is the difference between Embedded mode and the default mode in Humanizer?

The default pasted text mode returns the rewritten content alongside auxiliary metadata—including lists of detected AI patterns and processing summaries. Embedded mode returns **only** the final text string, eliminating the need for downstream systems to parse JSON structures or filter extraneous data.

### How do I trigger Embedded mode in a CI pipeline?

Specify `mode: embedded` in your configuration payload when invoking the Humanizer action or API endpoint. The skill processor detects this parameter and activates the streamlined output branch, as implemented in the request handling logic.

### Can Embedded mode be inferred automatically without specifying the mode parameter?

Yes. According to the source implementation in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), the skill infers Embedded mode when the caller context matches specific automation scenarios—such as pull request generation, commit message creation, or document building—even without an explicit `mode` declaration in the request payload.

### Where is Embedded mode defined in the Humanizer source code?

The formal specification appears in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) at lines 52–53. Usage documentation for the three modes exists in [`README.md`](https://github.com/blader/humanizer/blob/main/README.md), while [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md) provides information about automation agents capable of invoking the skill in Embedded mode.