# Show HN: Editor UI toolkit for building AI writing workflows

> Source: <https://imperavi.com/redactor/ai-assistant/>
> Published: 2026-08-20 09:09:31+00:00

Model-agnostic · Server-side prompts · Structured document context · Sync, jobs, or custom transport

Redactor provides the document editor and review UI. You connect your own backend, prompts, and model.

How it works

Redactor sends the selected blocks or the full document as structured context.

Your endpoint chooses the prompt, model, limits, logging, and data policy.

The response becomes a review, report, list of alternatives, or an applied document change.

Redactor does not require a specific AI provider and does not add per-token billing.

Integration

The editor sends an action ID and document context. Your backend selects the full prompt, calls the model, and returns the response shape expected by the selected mode.

Minimal initialization

```
Redactor('#entry', {
  plugins: ['assistant'],
  ai: {
    url: '/api/ai/text',
    model: 'your-model'
  }
});
```

Minimal request

```
{
  "action": "shorter",
  "mode": "review",
  "context": {
    "scope": "blocks",
    "blocks": [
      {
        "uid": "block-3",
        "type": "text",
        "tag": "p",
        "content": "..."
      }
    ]
  },
  "lang": "en",
  "model": "your-model"
}
```

One integration, several editing surfaces

| Mode | Backend returns | Redactor shows |
|---|---|---|
`review` |
Issues and suggested content | Review cards with accept/reject |
`apply` |
Directly applicable issues | Changes or inline annotations |
`report` |
Title, tab and HTML | A document report tab |
`report-review` |
Report and optional issues | Report with reviewable fixes |

Actions

Define actions around your own content, users, and editorial rules. Each action can use selected blocks or the full document, send additional context to your backend, and present the result as a review, an applied change, or a report.

Built-in actions provide working examples, but the menu, prompts, models, response handling, and application logic can all be adapted to your project.

The editor sends an action ID and structured document context to your backend. Your application decides how that request is processed and what is returned.

The Assistant is not tied to a particular model provider. Your backend can call OpenAI, Claude, a local model, or a custom service as long as it returns the expected response format.

Events let the host application inspect and modify the Assistant workflow at each important stage.

Hooks that can change content or requests run before the corresponding action. Lifecycle events provide the result after the action has completed.

Choose how Assistant requests reach your application. All transports use the same action context and return the same review or report response formats.

Send an HTTP request and return the completed result in the same response.

Create an asynchronous job and poll your application until the result is ready.

Provide a JavaScript request handler instead of using the built-in HTTP transports.

The Assistant uses a small request and response contract. These guides cover the backend, prompt templates, asynchronous processing, and report output.

Define server-side prompt templates that receive structured document blocks and return JSON for reviews, changes, and reports.

See request and response formats with backend examples for OpenAI, Claude, text actions, and image generation.

Implement the create-and-poll protocol for long documents, queued processing, and slower models.

Use the included HTML framework to present summaries, writing checks, key points, and other structured results in report tabs.

Review configuration options, action modes, response formats, transports, events, and extension points.

Pricing

Add-on for Redactor Core · Core not included

Includes the AI Assistant, review workflows, reports, configurable actions, transport options, and full source code.

Uses your own backend and model provider. AI requests and token usage are not included.

Licenses are perpetual for the purchased versions. Assistant Suite updates are free for the current Redactor Core major version. A paid Assistant upgrade may be required when moving to a new major version of Core.

FAQ

How the Assistant connects to your backend, what the license includes, and what remains under your application’s control.

No. You connect it to your own backend and model provider.

No. It is an add-on and requires a separate Core license.

No. Provider usage is billed according to the model and infrastructure you choose.

Yes. Actions are identified by IDs and can be mapped to server-side prompt templates or application logic.

Yes. The integration is based on Redactor’s request and response contract, not a specific provider SDK.

The jobs transport supports asynchronous create-and-poll workflows for long documents and queued processing.

Yes. Review actions present the original and suggested content and let the author accept or reject each change.