This is the full developer documentation for EkLine
# How EkLine Docs Reviewer works
> Learn how EkLine Docs Reviewer automates documentation quality checks, enforces style guides, and catches errors in GitHub, GitLab, and Bitbucket pull requests.
EkLine treats documentation like code. We lint your prose, enforce your style guide, and catch errors before they merge.
[Run your first doc check ](/reviewer/quickstart/)Pick your setup and get started in 3 minutes.
## How EkLine works
[Section titled “How EkLine works”](#how-ekline-works)
EkLine provides two AI-powered tools for documentation:
### Docs reviewer — quality assurance for docs
[Section titled “Docs reviewer — quality assurance for docs”](#docs-reviewer--quality-assurance-for-docs)
The Docs Reviewer agent runs in your CI/CD pipeline and reviews documentation changes in every Pull Request. It catches:
* **Style violations** — Active voice, sentence length, readability
* **Grammar issues** — Spelling, punctuation, syntax
* **Terminology inconsistencies** — Enforce product names, technical terms
* **Structural problems** — Heading hierarchy, link validity
When issues occur, EkLine posts inline comments directly on the PR. You can configure it to block merges until you resolve the issues.
**Supported platforms:** GitHub Actions, GitLab CI, Bitbucket Pipelines
### Docs Agent — AI-powered documentation generation
[Section titled “Docs Agent — AI-powered documentation generation”](#docs-agent--ai-powered-documentation-generation)
Docs Agent analyzes your codebase and generates documentation automatically:
* **API references** from function signatures and types
* **README files** with project overviews
* **Getting started guides** for onboarding
Access it from the [EkLine dashboard](https://ekline.io/dashboard) or directly in VS Code.
## Configuration
[Section titled “Configuration”](#configuration)
EkLine is fully customizable. You can manage rules, have custom guidelines, implement AI rules, add company specific terminology, and configure your own dictionary for your documentation creation and review.
**Configuration options:**
* [Configuration file](/reviewer/integrations/cli-integration#configuration-file) — Store settings in `ekline.config.json` for team consistency
* [Ignoring rules](/reviewer/configuration/ignoring-rules) — Handle false positives with inline comments or config
* [Framework support](/reviewer/configuration/framework-support) — Configure EkLine for Mintlify, Docusaurus, Astro, and more
* [Custom rules](https://ekline.io/guidelines/rules) — Create your own style rules
Tip
Start with a preset style guide (Google, Microsoft, or Marketing) and customize from there.
## Integrations
[Section titled “Integrations”](#integrations)
| Platform | Use case | Guide |
| ------------------- | ------------------------------- | ------------------------------------------------------------ |
| GitHub Actions | PR review automation | [Setup guide](/reviewer/integrations/github-integration/) |
| GitLab CI | MR review automation | [Setup guide](/reviewer/integrations/gitlab-integration/) |
| Bitbucket Pipelines | PR review automation | [Setup guide](/reviewer/integrations/bitbucket-integration/) |
| VS Code | Real-time feedback + Docs Agent | [Setup guide](/reviewer/integrations/vscode-integration/) |
| CLI | Local checks, CI flexibility | [Setup guide](/reviewer/integrations/cli-integration/) |
## Support
[Section titled “Support”](#support)
* **Email:**
* **Dashboard:** [ekline.io/dashboard](https://ekline.io/dashboard)
# Docs Agent — AI-powered documentation assistant
> AI-powered assistant that generates, updates, and reviews your technical documentation. Create API references, guides, and READMEs from your codebase.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
### See Docs Agent in action
[Section titled “See Docs Agent in action”](#see-docs-agent-in-action)
[Docs Agent Demo](https://www.youtube.com/embed/xn3cq_dfQVY)
Docs Agent is an AI assistant that helps you create documentation from your codebase, keep docs in sync when code changes, and improve existing content.
## What you can do
[Section titled “What you can do”](#what-you-can-do)
Generate new docs
Create README files, API references, and guides from your code, videos, or external sources.
Update from tickets
Reference a Linear or Jira ticket and the agent updates relevant documentation automatically.
Review and improve
Get feedback on clarity, completeness, accuracy, and consistency.
Pull from integrations
Reference Slack threads, Notion pages, Confluence docs, or Google Docs in your prompts.
Trigger from GitHub
Mention `@ekline-ai` on any pull request comment to generate docs linked to the PR context.
## How it works
[Section titled “How it works”](#how-it-works)
1. **Describe what you need** — Tell the agent what documentation to create or update.
2. **Agent analyzes your sources** — It reads your codebase, tickets, or linked content.
3. **Review the output** — Edit the generated content in the built-in editor.
4. **Create a pull request** — Publish changes through your normal review process.
The agent learns from your existing documentation to match your style, terminology, and structure.
## What you can create
[Section titled “What you can create”](#what-you-can-create)
* **README files** — From repository structure and code.
* **API references** — From function signatures, types, and comments.
* **How-to guides** — From support threads or internal knowledge.
* **Release notes** — From completed tickets in a milestone.
* **Getting started guides** — For new users or contributors.
* **Troubleshooting docs** — From incident resolutions or FAQs.
## Next steps
[Section titled “Next steps”](#next-steps)
[Getting started ](/agent/getting-started/)Create your first document in 5 minutes
[Integrations ](/agent/integrations/)Connect Slack, Notion, Linear, and more
[Enforce style guides ](/reviewer/quickstart/)Catch quality issues automatically with Docs Reviewer
# 404
> We couldn't find that page. Try searching, or head back to the docs home.
# Automatic documentation review on pull requests
> EkLine automatically detects when pull requests need documentation updates and suggests or creates them based on confidence level.
Request access
Docs Agent is available to all plans, but you must request access. Contact to request access.
When you open a pull request, EkLine automatically analyzes the changes and determines whether your documentation needs updating. Depending on the confidence of the assessment, EkLine stays silent, posts a suggestion, or triggers a documentation update automatically.
## How it works
[Section titled “How it works”](#how-it-works)
```
flowchart TD
A[Pull request opened] --> B[EkLine analyzes PR diff]
B --> C{Documentation impact?}
C -->|Low confidence| D[No action taken]
C -->|Medium confidence| E[Posts suggestion comment]
C -->|High confidence| F[Posts auto-trigger comment]
F --> G[Docs update flow runs automatically]
G --> H[Documentation PR created]
E --> I[You decide whether to trigger]
```
When a non-draft pull request is opened or converted from draft to ready, EkLine:
1. Reads the PR diff, title, and description.
2. Compares the changes against your existing documentation.
3. Assesses whether the changes have documentation impact.
4. Acts based on the confidence of that assessment.
Note
EkLine runs the assessment once per pull request. New commits pushed to the same PR do not trigger a re-analysis.
## Confidence tiers
[Section titled “Confidence tiers”](#confidence-tiers)
EkLine categorizes each assessment into one of three confidence tiers:
| Tier | When it applies | What EkLine does |
| ---------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Low** | Refactoring, test additions, bug fixes with no user-facing impact | Stays silent — no comment posted |
| **Medium** | Behavioral changes that might affect documented features | Posts a suggestion comment on the PR |
| **High** | New API endpoints, renamed configuration, removed features, changed public interfaces | Posts a comment that automatically triggers the docs update flow |
The high-confidence threshold is conservative. EkLine only auto-triggers a documentation update when the impact is clear. When uncertain, it defaults to staying silent.
### Medium confidence
[Section titled “Medium confidence”](#medium-confidence)
EkLine posts a comment on the pull request explaining what documentation might need updating. The comment mentions `@ekline-ai` so you can trigger the update manually if you agree.
No automatic action is taken — you decide whether to proceed.
### High confidence
[Section titled “High confidence”](#high-confidence)
EkLine posts a comment that automatically triggers the [GitHub PR bot](/agent/github-integration/) flow. The bot creates a documentation session, generates a draft, and opens a docs pull request — without any manual intervention.
This works the same way as manually mentioning `@ekline-ai` on a PR comment, except EkLine initiates it for you.
## Prerequisites
[Section titled “Prerequisites”](#prerequisites)
Before automatic PR review works on your repositories, you need:
* An EkLine organization account.
* The [EkLine GitHub App](https://ekline.io/settings) installed on the repository.
* Docs Agent access enabled for your organization (includes the GitHub PR bot integration).
Automatic PR review is enabled by default for all organizations with Docs Agent access.
## What you see on the pull request
[Section titled “What you see on the pull request”](#what-you-see-on-the-pull-request)
| Scenario | What appears on the PR |
| ----------------------- | ---------------------------------------------------------------------------------------- |
| Low confidence | Nothing — EkLine stays silent |
| Medium confidence | A comment suggesting a documentation update, with `@ekline-ai` mentioned for convenience |
| High confidence | A comment that triggers the docs update flow, followed by a link to the documentation PR |
| Error during assessment | Nothing — EkLine stays silent and logs the error internally |
At most one automatic review comment appears per pull request.
## Relationship to the GitHub PR bot
[Section titled “Relationship to the GitHub PR bot”](#relationship-to-the-github-pr-bot)
Automatic PR review builds on top of the existing [GitHub PR bot](/agent/github-integration/) integration:
* **Manual flow**: You mention `@ekline-ai` in a PR comment to trigger a documentation session.
* **Automatic flow**: EkLine posts the `@ekline-ai` mention for you when it detects high-confidence documentation impact.
Both flows create the same type of documentation session. If EkLine already posted an automatic comment and you mention `@ekline-ai` manually on the same PR, the existing session resumes rather than creating a duplicate.
## Run a manual assessment
[Section titled “Run a manual assessment”](#run-a-manual-assessment)
You can also trigger a PR documentation assessment on demand using the `/analyze-pr-for-docs-needs` command in the EkLine Docs Agent. Provide the PR URL as an argument:
```text
/analyze-pr-for-docs-needs https://github.com/your-org/your-repo/pull/123
```
The agent analyzes the PR diff against your existing documentation and acts based on the same confidence model described above. Use this when you want to assess a specific PR without waiting for the automatic trigger, or to re-assess a PR after significant changes.
## Current limitations
[Section titled “Current limitations”](#current-limitations)
* **Assessment runs once**: New commits pushed after the initial assessment do not trigger a re-analysis.
* **No user configuration**: You cannot customize confidence thresholds or trigger conditions. This is planned for a future release.
* **PR context only**: The assessment uses the PR diff, title, and description. Linked Jira or Linear tickets are not included.
* **Current PR changes only**: EkLine assesses documentation impact for changes introduced by the PR, not pre-existing documentation gaps.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Issue | Solution |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| No comment appears on my PR | Verify the EkLine GitHub App is installed and Docs Agent access is enabled for your organization. Draft PRs are skipped. Low-confidence assessments produce no comment. |
| EkLine posted a suggestion but I want the update | Mention `@ekline-ai` in a new comment on the PR with a description of the documentation changes you need. |
| The auto-triggered docs PR is inaccurate | Comment on the generated docs PR mentioning `@ekline-ai` with feedback. The agent resumes the session and pushes new commits. |
| EkLine triggered on a PR that does not need docs | The assessment is best-effort. You can close or ignore the generated docs PR. |
## Next steps
[Section titled “Next steps”](#next-steps)
* [GitHub PR bot](/agent/github-integration/) — Trigger documentation sessions manually from PR comments.
* [Create documentation](/agent/create/) — Generate documentation from your codebase, videos, and external sources.
* [Update and review](/agent/update-review/) — Keep documentation in sync with code changes.
# Create documentation with Docs Agent
> Generate new documentation from your codebase, video uploads, screenshots, or external sources.
Use create mode when you need documentation that doesn’t exist yet. The agent can generate content from your code, uploaded videos, or content pulled from integrations.
## From your codebase
[Section titled “From your codebase”](#from-your-codebase)
The agent analyzes your repository structure, source files, package configuration, and existing documentation to generate new content.
### README files
[Section titled “README files”](#readme-files)
Generate a comprehensive README when starting a new project or updating an outdated one.
```plaintext
Generate a README for this repository. Include:
- Project overview and key features
- Installation with npm and yarn
- Quick start example
- Configuration options
- Contributing guidelines
```
**Tips:**
* Mention specific sections you need.
* Reference example code: `"Include examples similar to /examples"`
* Specify the audience: `"Write for developers familiar with React"`
### API reference
[Section titled “API reference”](#api-reference)
Document endpoints, functions, or modules from your source code.
```plaintext
Document the authentication endpoints in src/api/auth.ts.
Include request parameters, response schema, example
requests, and error codes.
```
The agent extracts and documents:
* Endpoint URLs and HTTP methods
* Request parameters with types and descriptions
* Response schema with field descriptions
* Example request and response bodies
* Error responses and status codes
### How-to guides
[Section titled “How-to guides”](#how-to-guides)
Create task-oriented guides for common workflows.
```plaintext
Create a how-to guide for setting up local development.
Cover environment setup, database configuration, and
running the test suite.
```
### Getting started guides
[Section titled “Getting started guides”](#getting-started-guides)
Help new users or contributors get up and running.
```plaintext
Write a getting started guide for new contributors.
Include repo setup, coding standards, and how to
submit a pull request.
```
## From video uploads
[Section titled “From video uploads”](#from-video-uploads)
Upload product demos, tutorials, or walkthroughs to generate documentation. The agent transcribes the video and creates structured content from what it sees and hears.
Supported formats
**Video formats:** MP4, WebM, MOV, AVI, MPEG, OGG **Maximum size:** 500 MB
### How it works
[Section titled “How it works”](#how-it-works)
1. Click the attachment icon in the chat panel.
2. Select your video file.
3. Wait for processing. Transcription may take a few minutes.
4. Describe what documentation you need.
### Example prompts
[Section titled “Example prompts”](#example-prompts)
* Tutorial from demo
```plaintext
Create a step-by-step tutorial from this product demo.
Include descriptions of each screen and action shown.
```
* Feature overview
```plaintext
Write a feature overview document based on this
walkthrough video. Focus on the key capabilities
demonstrated.
```
* Release notes
```plaintext
Generate release notes from this demo of new features.
Summarize each feature shown for end users.
```
## From screenshots and images
[Section titled “From screenshots and images”](#from-screenshots-and-images)
Upload screenshots, diagrams, or other images and the agent inserts them directly into your documentation. The agent sees the image content and places it in the appropriate location within your repository.
Supported formats
**Image formats:** JPEG, PNG, GIF, WebP **Maximum size:** 50 MB
### How it works
[Section titled “How it works”](#how-it-works-1)
1. Click the attachment icon in the chat panel.
2. Select your image file.
3. Describe where and how you want the image placed.
4. The agent downloads the image into your repository and adds a markdown reference.
The agent can see image content, so it understands what the screenshot shows and can write appropriate alt text and captions.
### Example prompts
[Section titled “Example prompts”](#example-prompts-1)
* Insert screenshot
```plaintext
Insert this screenshot into the getting started guide
after the installation section. Add a caption describing
what the user should see.
```
* Add diagram
```plaintext
Add this architecture diagram to the overview page.
Place it after the "How it works" section.
```
* Multiple images
```plaintext
Add these screenshots to the deployment guide. Place
each one next to the step it illustrates.
```
Tip
Binary files like images appear as placeholders in the editor since they can’t be previewed inline. You can verify image placement by checking the markdown references in the surrounding document.
## From external sources
[Section titled “From external sources”](#from-external-sources)
Pull content from connected integrations to create documentation. See [Integrations](/agent/integrations) to connect your tools.
### From Slack threads
[Section titled “From Slack threads”](#from-slack-threads)
Turn support conversations and internal discussions into structured documentation.
```plaintext
Create a troubleshooting guide based on this Slack thread:
https://workspace.slack.com/archives/C01234/p1234567890
```
The agent extracts the conversation, identifies the problem and solution, and formats it as documentation.
### From Notion pages
[Section titled “From Notion pages”](#from-notion-pages)
Transform product specs, design documents, or meeting notes into user-facing docs.
```plaintext
Create API documentation based on the spec in this Notion page:
https://notion.so/your-workspace/api-spec-page
```
### From Confluence pages
[Section titled “From Confluence pages”](#from-confluence-pages)
Pull technical specifications or internal knowledge into your docs.
```plaintext
Create a deployment guide based on the runbook in this
Confluence page: https://your-org.atlassian.net/wiki/...
```
### Release notes from tickets
[Section titled “Release notes from tickets”](#release-notes-from-tickets)
Generate changelogs from completed Linear or Jira tickets.
```plaintext
Generate release notes for v2.1 based on Linear tickets
ENG-100 through ENG-110. Organize by Features,
Improvements, and Bug Fixes. Write for end users.
```
The agent reads each ticket’s title, description, and comments to create user-facing summaries.
## Tips for better output
[Section titled “Tips for better output”](#tips-for-better-output)
Write better prompts
* **Be specific about sections** — List exactly what you want included.
* **Reference existing docs** — `"Match the style of docs/quickstart.md"`.
* **Specify the audience** — `"Write for developers new to Kubernetes"`.
* **Mention your stack** — `"This is a Django project using PostgreSQL"`.
* **Set the tone** — `"Keep it concise and focus on practical examples"`.
# Create documentation from a demo video
> Upload a product demo or walkthrough video and use Docs Agent to turn it into a review-ready guide in a pull request.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
This tutorial shows you how to turn a product demo video into written documentation. You upload a walkthrough, Docs Agent transcribes it and reads what happens on screen, and you guide the agent to produce a structured guide that matches your existing docs.
By the end, you have a step-by-step guide drafted from your video and opened as a pull request, ready for review.
## Before you begin
[Section titled “Before you begin”](#before-you-begin)
You need:
* An EkLine account with Docs Agent enabled.
* A repository [connected to EkLine](/agent/github-app-setup/) where the documentation lives.
* A demo or walkthrough video that shows the feature you want to document.
Your video must meet these limits:
| Requirement | Value |
| ------------ | ------------------------- |
| Formats | MP4, WebM, MOV, AVI, MPEG |
| Maximum size | 500 MB |
New to EkLine? [Connect GitHub to EkLine](/agent/github-app-setup/) first, then return here.
## Step 1: Prepare your demo video
[Section titled “Step 1: Prepare your demo video”](#step-1-prepare-your-demo-video)
A clear video produces a clear draft. Before you upload, check the following:
* **Narrate the important actions.** The agent transcribes the audio, so spoken explanations become part of the source material.
* **Move at a steady pace.** Pause briefly on each screen so the actions are easy to follow.
* **Trim dead air.** Cut long silences or unrelated tangents to keep the transcription focused.
* **Confirm the format and size.** Export as MP4, WebM, MOV, AVI, or MPEG, and keep the file under 500 MB.
A three-to-ten-minute screen recording with narration works well for a single feature.
## Step 2: Open a session
[Section titled “Step 2: Open a session”](#step-2-open-a-session)
1. Log in to your [EkLine dashboard](https://ekline.io/dashboard).
2. Click **Docs Agent** in the left navigation.
## Step 3: Upload your video
[Section titled “Step 3: Upload your video”](#step-3-upload-your-video)
1. Click the attachment icon in the chat panel.
2. Select your video file.
3. Wait for processing. Transcription runs before the agent can use the video, and it may take a few minutes for a longer recording.
The video appears as an attachment in the chat panel once processing finishes.
Tip
You can attach up to 20 files to a single message. Add a screenshot alongside the video if you want the agent to use a specific frame as an image in the guide.
## Step 4: Describe the documentation you want
[Section titled “Step 4: Describe the documentation you want”](#step-4-describe-the-documentation-you-want)
Tell the agent what to build from the video. Naming the document type and audience keeps the output focused.
* Step-by-step tutorial
```plaintext
Create a step-by-step tutorial from this product demo.
Describe each screen and action shown, and write it for a
new user trying the feature for the first time.
```
* Feature overview
```plaintext
Write a feature overview based on this walkthrough video.
Focus on the key capabilities demonstrated and who they
help.
```
* Release notes
```plaintext
Generate release notes from this demo of new features.
Summarize each feature shown for end users.
```
To match your existing docs, point the agent at a similar page:
```plaintext
Create a step-by-step tutorial from this demo video. Match the
structure and tone of docs/tutorials/getting-started.md.
```
The agent analyzes the transcription and the on-screen content, then drafts the guide in the editor panel.
## Step 5: Review the draft
[Section titled “Step 5: Review the draft”](#step-5-review-the-draft)
Read the draft in the editor panel and check it against the video:
* The steps follow the same order as the demo.
* Screen names, button labels, and menu paths match what the video shows.
* The guide covers every action you demonstrated, with nothing invented.
Refine anything that is off by replying in the chat. For example:
```plaintext
Add a verification step after the install section that tells the
reader what a successful setup looks like.
```
The agent updates the draft in place. Repeat until the guide reads the way you want.
## Step 6: Publish as a pull request
[Section titled “Step 6: Publish as a pull request”](#step-6-publish-as-a-pull-request)
1. Enable **View All Changes** to see a diff of what the agent created.
2. Click **Raise PR** to open a pull request with the new guide.
3. The agent prefills a prompt in the chat. Press **Enter** to send it, or edit the prompt first to add instructions.
The agent opens the pull request and replies in the chat with a link where you continue the review on GitHub.
## Verify
[Section titled “Verify”](#verify)
Confirm the tutorial worked end to end:
* [ ] The uploaded video appears as an attachment in the chat panel.
* [ ] The editor panel shows a drafted guide that follows the demo.
* [ ] A pull request is open on your connected repository with the new file.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Issue | Solution |
| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| Upload is rejected | Check that the file is under 500 MB and in a supported format (MP4, WebM, MOV, AVI, MPEG). |
| Processing takes a long time | Transcription scales with video length. Wait a few minutes for longer recordings before sending your prompt. |
| The draft misses steps shown in the video | Narrate the missing actions in the recording, or describe them in a chat reply so the agent adds them. |
| Screen labels in the draft are wrong | Reply in the chat with the correct label and ask the agent to fix it. Attaching a screenshot of the screen helps. |
## Summary
[Section titled “Summary”](#summary)
You uploaded a demo video, guided Docs Agent to turn it into a structured guide, reviewed the draft against the recording, and opened a pull request. Your walkthrough is now written documentation your team can review and merge.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Create documentation](/agent/create/) — Generate docs from your codebase, screenshots, and external sources.
* [Update and review documentation](/agent/update-review/) — Keep the guide in sync as the feature changes.
* [Generate an API reference](/agent/generate-api-reference/) — Turn source code into reference documentation.
# Generate an API reference from your codebase
> Use Docs Agent to turn your source code into a complete, accurate API reference with parameters, response schemas, and examples.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
This guide shows you how to generate an API reference directly from your source code. Docs Agent reads your function signatures, types, and comments, then produces reference documentation with parameters, response schemas, example requests, and error codes — no manual transcription from code to docs.
By the end, you have a review-ready API reference in a pull request.
## Before you begin
[Section titled “Before you begin”](#before-you-begin)
You need:
* An EkLine account with Docs Agent enabled.
* A repository [connected to EkLine](/agent/github-app-setup/) that contains the API source code you want to document.
* The path to the file or directory that defines your API — for example, `src/api/auth.ts` or `src/routes/`.
New to EkLine? [Connect GitHub to EkLine](/agent/github-app-setup/) first, then return here.
## Step 1: Open a session
[Section titled “Step 1: Open a session”](#step-1-open-a-session)
1. Log in to your [EkLine dashboard](https://ekline.io/dashboard).
2. Click **Docs Agent** in the left navigation.
## Step 2: Point the agent at your API source
[Section titled “Step 2: Point the agent at your API source”](#step-2-point-the-agent-at-your-api-source)
Reference the exact file or directory that defines your endpoints. Naming the source keeps the agent focused and improves accuracy.
* Single file
```plaintext
Document the endpoints in src/api/auth.ts. Include request
parameters, response schema, example requests, and error
codes.
```
* Directory
```plaintext
Generate an API reference for every route in src/routes/.
Group the endpoints by resource, and for each one include
the HTTP method, parameters, response schema, and error
responses.
```
* Specific endpoints
```plaintext
Document the POST /users and GET /users/:id endpoints in
src/api/users.ts. Include request and response examples
with realistic values.
```
For each endpoint, the agent extracts:
* Endpoint URLs and HTTP methods
* Request parameters with types and descriptions
* Response schema with field descriptions
* Example request and response bodies
* Error responses and status codes
## Step 3: Review the generated reference
[Section titled “Step 3: Review the generated reference”](#step-3-review-the-generated-reference)
The agent writes the reference to the editor panel as it works. Read through the output and confirm it matches your code:
* Endpoint paths and methods are correct.
* Every parameter your code accepts appears in the reference.
* Response fields match what your code returns.
## Step 4: Refine with follow-up prompts
[Section titled “Step 4: Refine with follow-up prompts”](#step-4-refine-with-follow-up-prompts)
Add detail or fix gaps by continuing the conversation. The agent keeps the context from your first prompt, so you can build on the reference incrementally.
* Add examples
```plaintext
Add a curl example and a JavaScript fetch example to each
endpoint.
```
* Document errors
```plaintext
Add an error table to each endpoint listing the status code,
error message, and cause.
```
* Match your style
```plaintext
Match the structure and tone of docs/api/payments.md.
```
Tip
Point the agent at an existing reference page with `"Match the structure of docs/api/payments.md"` so new endpoints follow the same layout as the rest of your API docs.
## Step 5: Raise a pull request
[Section titled “Step 5: Raise a pull request”](#step-5-raise-a-pull-request)
1. Enable **View All Changes** in the toolbar to see a diff of the generated reference.
2. Make any final edits directly in the editor panel.
3. Click **Raise PR**. The agent prefills a prompt in the chat — press **Enter** to send it, or edit the prompt first to add instructions.
The agent opens the pull request and replies in the chat with a link to continue the review on GitHub.
## Verify the reference is accurate
[Section titled “Verify the reference is accurate”](#verify-the-reference-is-accurate)
Before you merge, confirm the reference reflects your code:
* **Signatures match.** Every parameter name, type, and required or optional flag matches the source.
* **Examples run.** Copy an example request and run it against your API. The response matches the documented schema.
* **Errors are complete.** Each documented status code corresponds to an error your code actually returns.
* **Nothing is missing.** Every endpoint in the referenced file or directory appears in the output.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Problem | Cause | Fix |
| ----------------------------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| The agent misses endpoints | The prompt was too broad, or endpoints span several files | Name each file explicitly, or reference the parent directory: `"Document every route in src/routes/"` |
| Parameter descriptions are vague | Your source code lacks comments or type annotations for those parameters | Add doc comments or types in the source, then regenerate — or supply the descriptions in a follow-up prompt |
| Example values look generic | The agent had no sample data to draw from | Ask for realistic values: `"Use realistic example values based on the types in the code"` |
| The reference mixes in conceptual content | The prompt asked for explanation alongside reference | Keep the prompt reference-focused, and generate concepts separately with [Create documentation](/agent/create/) |
## Next steps
[Section titled “Next steps”](#next-steps)
* [Update and review](/agent/update-review/) — Keep the reference in sync when your API changes.
* [Create documentation](/agent/create/) — Generate READMEs, guides, and more from the same codebase.
* [Set up automated style checks](/reviewer/quickstart/) — Catch style and terminology issues on every pull request with Docs Reviewer.
# Getting started with Docs Agent
> Create your first document with Docs Agent in under 5 minutes.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
## Before you begin
[Section titled “Before you begin”](#before-you-begin)
You need:
* An EkLine account with Docs Agent enabled
* At least one repository [connected to EkLine](/agent/github-app-setup/)
New to EkLine? [Connect GitHub to EkLine](/agent/github-app-setup/) to install the GitHub App and choose which repositories the agent can access.
Don’t have access? Email **** with your organization name.
## Open the editor
[Section titled “Open the editor”](#open-the-editor)
1. Log in to your [EkLine dashboard](https://ekline.io/dashboard).
2. Click **Docs Agent** in the left navigation.
The editor interface has three main areas:
| Area | Location | Purpose |
| ---------------- | -------- | -------------------------------------- |
| **Editor panel** | Left | View and edit generated documentation |
| **Chat panel** | Right | Interact with the AI agent |
| **Toolbar** | Top | View changes, switch files, create PRs |
## Create your first document
[Section titled “Create your first document”](#create-your-first-document)
Generate a README for your repository:
1. In the chat panel, type:
```plaintext
Generate a README for this repository. Include installation
instructions, usage examples, and contributing guidelines.
```
2. Wait while the agent analyzes your repository structure and code.
3. Review the generated content in the editor panel.
4. Enable **View All Changes** to see a diff of what the agent created.
5. Click **Raise PR** to open a pull request with the new documentation. The agent prefills a prompt in the chat — press **Enter** to send it, or edit the prompt first to add instructions.
The agent creates the pull request and responds in the chat with a link where you can continue the review process on GitHub.
## Control the agent while it works
[Section titled “Control the agent while it works”](#control-the-agent-while-it-works)
The chat input button changes color to reflect what the agent is doing:
| State | Icon | Action |
| --------- | -------- | ------------------------------------------------------------ |
| **Send** | Arrow up | Send a new message (agent is idle) |
| **Stop** | Stop | Cancel the current turn (agent is working, text field empty) |
| **Queue** | Plus | Queue a follow-up that sends after the current turn finishes |
Click the **Stop** button to cancel a turn mid-flight. Any partial work stays in the editor for you to review. To queue a follow-up, type your message while the agent works and press **Enter**. Queued messages appear with a clock icon and are delivered together when the turn completes. Click a queued message to edit it, or click the **X** icon to cancel it.
## Write better prompts
[Section titled “Write better prompts”](#write-better-prompts)
The more context you give, the better the output.
| Instead of… | Try… |
| -------------------- | ------------------------------------------------------------------------------------------- |
| ”Write docs" | "Create a getting started guide for Python developers" |
| "Update the README" | "Add a Docker installation section to the README" |
| "Help with API docs" | "Document the POST /users endpoint in src/api/users.ts with request and response examples" |
| "Make release notes" | "Generate release notes for tickets ENG-100 through ENG-105, grouped by Features and Fixes” |
Write better prompts
* Reference specific files: `"Look at src/api/auth.ts"`.
* Mention your framework: `"This is a Next.js project"`.
* Specify the audience: `"Write for developers new to GraphQL"`.
* Point to style examples: `"Match the tone of docs/quickstart.md"`.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Create documentation](/agent/create/) — Generate READMEs, API refs, and guides.
* [Update and review](/agent/update-review/) — Keep docs in sync with code changes.
* [Integrations](/agent/integrations/) — Pull content from Slack, Notion, Linear, and more.
* [Set up automated style checks](/reviewer/quickstart/) — Enforce style guides and catch quality issues on every pull request with Docs Reviewer.
# Connect GitHub to EkLine Docs Agent
> Install the EkLine GitHub App and configure which repositories and documentation paths to monitor.
Connect your GitHub organization to EkLine so Docs Agent can monitor your repositories, review pull requests, and generate documentation automatically.
## Prerequisites
[Section titled “Prerequisites”](#prerequisites)
* An EkLine account with an organization. [Sign up](https://ekline.io) if you haven’t already.
* Admin access to the GitHub organization you want to connect.
## Install the GitHub App
[Section titled “Install the GitHub App”](#install-the-github-app)
1. **Open GitHub integration settings.**
Go to your [EkLine Dashboard](https://ekline.io/dashboard) and navigate to **Settings → Organization → GitHub Integration**.
2. **Start the installation.**
Click the **Install on another GitHub organization** button. This redirects you to GitHub to authorize the EkLine app.
Note
If this is your first GitHub connection, the button reads **Install the GitHub App**.
3. **Select your GitHub account.**
On the GitHub authorization page, select the user account you want to use to authorize EkLine.
4. **Select the target organization.**
Choose the GitHub organization where you want to install the EkLine app.
5. **Choose repository access.**
GitHub shows two options:
* **All repositories** — Grants EkLine access to every repository in the organization.
* **Only select repositories** — Lets you pick specific repositories.
Select **Only select repositories** and search for the repositories you want EkLine to monitor. You can always change this later in your GitHub organization settings.
Tip
Start with a few key documentation repositories. You can add more repositories at any time from the EkLine settings page.
6. **Complete the GitHub installation.**
Click the **Install** button. GitHub redirects you back to EkLine to complete the connection.
## Connect the organization in EkLine
[Section titled “Connect the organization in EkLine”](#connect-the-organization-in-ekline)
1. **Select your organization.**
On the **GitHub App Setup** page, use the **Select an organization** dropdown to choose the GitHub organization you installed the app on.
2. **Finish the connection.**
Click the **Connect GitHub** button. EkLine links your GitHub organization and loads the available repositories.
## Configure repositories
[Section titled “Configure repositories”](#configure-repositories)
After connecting, the GitHub integration settings page shows two sections for adding repositories:
| Section | Purpose |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
| **Documentation Repositories** | Repositories containing your documentation files. Supports path configuration for targeting specific directories or files. |
| **Code Repositories** | Source code repositories that EkLine uses for context when generating or reviewing documentation. |
### Add documentation repositories
[Section titled “Add documentation repositories”](#add-documentation-repositories)
1. **Search and select a repository.**
Use the search field under **Documentation Repositories** to find and select a repository.
2. **Add documentation paths.**
Click the **Add Path** button next to the repository. Enter the file or directory path you want EkLine to monitor (for example, `docs/`, `README.md`, or `content/`).
Click **Save** to confirm. The path appears as a tag that you can remove later.
Tip
You can add multiple paths per repository. Use comma-separated values to add several paths at once.
3. **Enable monitoring.**
Toggle the **Enable monitoring** switch to let EkLine automatically monitor the repository for documentation changes.
4. **Save your configuration.**
Click **Save**. A success notification confirms that the GitHub integration has been updated.
### Add code repositories
[Section titled “Add code repositories”](#add-code-repositories)
Use the search field under **Code Repositories** to select source code repositories. These provide EkLine with additional context for documentation generation and review but do not require path configuration.
## Verify the connection
[Section titled “Verify the connection”](#verify-the-connection)
After completing the setup, confirm everything is working:
* The **GitHub App installations** section shows your connected organization.
* Your selected repositories appear under **Documentation Repositories** or **Code Repositories**.
* Documentation paths are displayed as tags next to their repositories.
* The **Enable monitoring** toggle is active for repositories you want to track.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Use the GitHub PR bot](/agent/github-integration/) to generate documentation from pull request comments.
* [Set up automatic PR review](/agent/automatic-pr-review) so EkLine detects when PRs need documentation updates.
* [Set up the GitHub Action](/reviewer/quickstart/github-action/) to run automated style checks on every pull request.
***
## Stuck?
[Section titled “Stuck?”](#stuck)
Reply to your welcome email or contact . We read every message.
# Generate documentation from GitHub pull requests
> Trigger Docs Agent from GitHub pull requests by mentioning @ekline-ai in PR comments or code review threads to generate documentation.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
Start documentation sessions without leaving GitHub. Mention `@ekline-ai` in any pull request comment or review thread, and the bot generates a documentation draft linked to the PR context.
## How it works
[Section titled “How it works”](#how-it-works)
When you mention `@ekline-ai` in a PR comment, the bot:
1. Reacts with a :eyes: emoji to acknowledge your request.
2. Posts a reply with a link to the EkLine editor where it creates the draft.
3. Generates documentation based on your prompt and the PR context.
4. Updates the reply with a link to the docs pull request when ready.
The bot works with any type of PR comment. When you mention `@ekline-ai` on a review comment attached to specific code lines, the agent also receives the file path and diff context for those lines.
## Prerequisites
[Section titled “Prerequisites”](#prerequisites)
Before you begin, you need:
* An EkLine organization account.
* The [EkLine GitHub App](/agent/github-app-setup/) installed on your organization.
* Docs Agent access enabled for your organization.
## Trigger the bot from a PR comment
[Section titled “Trigger the bot from a PR comment”](#trigger-the-bot-from-a-pr-comment)
1. Open a pull request on a repository where the EkLine GitHub App is installed.
2. Write a comment on the PR that mentions `@ekline-ai` followed by your documentation request.
```text
@ekline-ai Create a migration guide for the database schema changes in this PR.
```
3. The bot reacts with :eyes: to confirm it received your request.
4. A reply appears with a link to the EkLine editor session where the documentation is being drafted.
5. Review and edit the draft in the EkLine editor.
6. When the agent finishes, it opens a docs pull request on your configured documentation repository. The bot updates its reply with a link to the docs PR.
## Trigger the bot from a code review comment
[Section titled “Trigger the bot from a code review comment”](#trigger-the-bot-from-a-code-review-comment)
For more targeted documentation, mention the bot on specific lines in a code review.
1. Start a review on the pull request, or view the **Files changed** tab.
2. Select the line or lines you want to reference, and add a review comment that mentions `@ekline-ai`.
```text
@ekline-ai Document this new API endpoint, including the request and response schema.
```
3. The bot reacts with :eyes: and replies in the review thread.
4. The agent receives the file path and diff hunk for the lines you commented on, along with your prompt.
5. Review the generated draft in the EkLine editor and the resulting docs PR.
Use line comments for precision
Review comments on specific code lines provide the file path and diff context to the agent. Use these when your request relates to a particular code change, such as a new endpoint, configuration option, or function.
## What the bot posts
[Section titled “What the bot posts”](#what-the-bot-posts)
The bot communicates progress through comments on the pull request:
| Stage | What the bot posts |
| ---------------- | ------------------------------------------------------------------------------- |
| Request received | :eyes: reaction on your comment |
| Session started | Reply with a link to the EkLine editor |
| Docs PR created | Updated reply with a link to the new documentation pull request |
| Docs PR updated | Updated reply noting that the bot updated the existing docs PR with new changes |
| Error | Reply with an error message describing what went wrong |
If you mention the bot again on the same PR, it resumes the existing session rather than starting a new one.
## Write effective prompts
[Section titled “Write effective prompts”](#write-effective-prompts)
The quality of your prompt determines the quality of the output. The bot strips the `@ekline-ai` mention and passes the rest of your comment as the prompt.
| Instead of\u2026 | Try\u2026 |
| ---------------- | ---------------------------------------------------------------------------- |
| ”document this" | "Create an API reference for the new `/users` endpoint added in this PR" |
| "update docs" | "Update the authentication guide to cover the OAuth flow changes in this PR" |
| "help with docs" | "Write a migration guide for the breaking changes to the config schema” |
**Include specific details:**
* Name the type of documentation you need: API reference, migration guide, tutorial, how-to.
* Reference specific files or changes in the PR.
* Mention existing documentation to update if applicable.
* Give any audience context, such as whether it’s for developer docs or an end-user guide.
## Follow-up comments
[Section titled “Follow-up comments”](#follow-up-comments)
After the bot creates a docs PR, you can continue the conversation:
* **Comment on the source PR** — Mention `@ekline-ai` again to refine or extend the documentation. The bot resumes the existing session and updates the docs PR.
* **Comment on the docs PR** — Mention `@ekline-ai` on the generated docs PR to request changes to the draft. The agent receives the docs PR context and pushes new commits.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Issue | Solution |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| Bot does not respond | Verify that the EkLine GitHub App is installed on the repository. Check that the GitHub PR integration is enabled for your organization. |
| Bot reacts but does not reply | The agent may be processing your request. Wait up to a minute. If no reply appears, try again or contact . |
| ”Error” reply from the bot | Read the error message for details. Common causes: session conflicts, service unavailability. Try again or contact support. |
| Docs PR not created | The agent creates a PR when it generates file drafts. If your prompt is ambiguous, the agent may not produce files. Give a more specific prompt. |
| Bot responds to the wrong person | The bot responds to any mention of `@ekline-ai` in the PR. Each mention triggers or resumes a session. |
## Next steps
[Section titled “Next steps”](#next-steps)
* [Create documentation](/agent/create) — Generate documentation from your codebase, videos, and external sources.
* [Slack bot](/agent/slack-bot) — Create documentation drafts directly from Slack.
* [Integrations](/agent/integrations) — Connect Notion, Linear, Jira, and other tools for richer context.
# Connect GitLab to EkLine Docs Agent
> Add a GitLab access token to connect your projects so Docs Agent can reference merge requests, issues, and repository files.
Connect GitLab to EkLine so Docs Agent can reference your merge requests, issues, and repository files when it generates and updates documentation.
GitLab connects with a GitLab access token. You add the token once at the organization level, and every member of your EkLine organization can then reference GitLab content in their Docs Agent sessions.
## Prerequisites
[Section titled “Prerequisites”](#prerequisites)
* An EkLine account with an organization. [Sign up](https://ekline.io) if you haven’t already.
* A GitLab account with access to the projects you want EkLine to reference.
* Permission in GitLab to create an access token with the required scopes.
## Generate a GitLab group access token
[Section titled “Generate a GitLab group access token”](#generate-a-gitlab-group-access-token)
A group access token covers every project in the group with a single token, so it’s the recommended option when your organization has multiple projects. EkLine also accepts personal and project access tokens if you prefer to scope access differently. For full details, see the [GitLab group access tokens reference](https://docs.gitlab.com/user/group/settings/group_access_tokens/).
1. **Open the group’s access tokens page in GitLab.**
Go to the group you want EkLine to access, then navigate to **Settings > Access tokens**.
Note
You need the Owner role on the group to create a group access token.
2. **Add a new token.**
Click **Add new token** and enter a recognizable name, such as `EkLine Integration`.
3. **Set an expiration date.**
Set the expiration as needed. EkLine tracks the expiration date and shows you when the token is close to expiring.
4. **Select a role.**
Select the **Developer** role or higher. The role determines what the token can read across the group’s projects.
5. **Select the required scopes.**
Select both the `api` and `read_repository` scopes. The connection fails without both.
6. **Create and copy the token.**
Click **Create group access token** and copy the generated token. The token starts with `glpat-`.
Caution
GitLab shows the token value only once. Copy it before you leave the page.
## Connect GitLab in EkLine
[Section titled “Connect GitLab in EkLine”](#connect-gitlab-in-ekline)
1. **Open GitLab integration settings.**
Go to your [EkLine Dashboard](https://ekline.io/dashboard) and navigate to **Settings > Organization > GitLab Integration**.
2. **Add your token.**
Click the **Update Token** button. Paste your GitLab token into the **GitLab Token** field.
3. **Save the token.**
Save your changes. EkLine validates the token, confirms the scopes, and stores it encrypted. When the connection succeeds, the status changes to **Token is set**.
Note
If you see the error “Invalid GitLab token”, confirm that the token starts with `glpat-` and has both the `api` and `read_repository` scopes.
## Select code repositories
[Section titled “Select code repositories”](#select-code-repositories)
After you connect a token, EkLine loads the GitLab projects the token can access.
1. **Find the Code Repositories section.**
The **Code Repositories** section lists the GitLab projects available to the token.
2. **Select your projects.**
Select the GitLab projects you want to use with Docs Agent.
3. **Save your selection.**
Save your changes to make the selected projects available in Docs Agent sessions.
## Configure the GitLab webhook
[Section titled “Configure the GitLab webhook”](#configure-the-gitlab-webhook)
A webhook lets GitLab notify EkLine about events in your project, such as new merge requests and comments. After you add a token, EkLine shows the **Webhook Configuration** section with the values you need.
1. **Copy the webhook details from EkLine.**
In the **Webhook Configuration** section on the GitLab integration settings page, copy the **Webhook URL** and the **Secret Token**.
2. **Open the webhooks page in GitLab.**
In your GitLab project, navigate to **Settings > Webhooks** and click **Add new webhook**.
3. **Enter the webhook URL and secret.**
Paste the EkLine webhook URL into the **URL** field, then paste the secret into the **Secret token** field.
4. **Select the triggers.**
Enable these triggers: **Push events**, **Comments**, **Emoji events**, and **Merge request events**.
5. **Save the webhook.**
Click **Add webhook**. GitLab now sends events to EkLine for that project.
Tip
Add the webhook to each GitLab project you want EkLine to monitor.
## Verify the connection
[Section titled “Verify the connection”](#verify-the-connection)
Confirm that the integration is ready:
* The token status shows **Token is set**.
* Your selected projects appear under **Code Repositories**.
* The **Webhook URL** and **Secret Token** appear in the **Webhook Configuration** section.
* A team member can reference a GitLab merge request or issue in a Docs Agent session and the agent fetches the content.
## Use GitLab content in Docs Agent
[Section titled “Use GitLab content in Docs Agent”](#use-gitlab-content-in-docs-agent)
After you connect GitLab, reference GitLab content directly in your prompts. The agent recognizes GitLab URLs and IDs automatically and pulls the details from your connected projects.
```text
Create a changelog entry based on this GitLab merge request:
https://gitlab.com/your-org/platform/-/merge_requests/42
```
```text
Update the authentication docs based on the changes in
GitLab issue #215.
```
```text
Document the new API endpoints by referencing the files
changed in merge request !87.
```
The agent accesses content using the permissions of the account that created the token. You can only pull content that account has permission to view.
Organization-level access
GitLab connects at the organization level. Once a team member adds a token, any organization member can use the integration through Docs Agent.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Docs Agent integrations](/agent/integrations) — see every source you can reference, including Slack, Notion, Jira, and Confluence.
* [Create documentation](/agent/create) — generate a draft from your connected sources.
* [Update and review](/agent/update-review) — refine and review documentation with the agent.
***
## Stuck?
[Section titled “Stuck?”](#stuck)
Reply to your welcome email or contact . We read every message.
# Docs Agent integrations
> Pull content from Slack, Notion, Linear, Jira, Confluence, GitLab, Google Drive, and PostHog into your documentation.
Reference external content directly in your prompts. Instead of copying and pasting, mention a Slack thread, Notion page, or ticket ID, and the agent pulls the content automatically.
## Available integrations
[Section titled “Available integrations”](#available-integrations)
| Integration | What you can reference |
| ---------------- | --------------------------------------------------- |
| **GitHub** | Pull request context, code diffs, and file changes |
| **GitLab** | Merge requests, issues, and repository files |
| **Slack** | Messages and threads |
| **Notion** | Pages and databases |
| **Linear** | Issues, descriptions, and comments |
| **Jira** | Issues, descriptions, and comments |
| **Confluence** | Pages and spaces |
| **Google Drive** | Files, folders, and documents |
| **PostHog** | Product analytics, feature flags, and HogQL queries |
## Connect an integration
[Section titled “Connect an integration”](#connect-an-integration)
1. Go to **Settings > Organization > Integrations** in your EkLine dashboard.
2. Find the integration you want to connect.
3. Click **Connect** and complete the authorization using an OAuth 2.0 popup or token entry, depending on the integration.
4. The integration is now available in all Docs Agent sessions.
Each team member connects their own account. The agent can only access content you have permission to view.
## GitHub
[Section titled “GitHub”](#github)
Trigger Docs Agent directly from pull request comments. Mention `@ekline-ai` on any PR comment or code review thread, and the bot creates a documentation draft linked to the PR context.
You can connect multiple GitHub organizations to a single EkLine organization. Repositories from all connected organizations appear in a combined list on the integrations page. To add another GitHub organization, click **Install on another GitHub organization** in the GitHub App installations section under **Settings > Organization > GitHub Integration**.
**Use cases:**
* Generate a migration guide from the changes in a PR.
* Document a new API endpoint by commenting on the specific code lines.
* Update existing docs based on a feature PR.
Create docs without leaving GitHub
Use the [GitHub PR bot](/agent/github-integration/) to mention `@ekline-ai` in any pull request. The bot reacts, creates a draft in EkLine, and opens a docs PR when ready.
Organization-level access
GitHub connects at the organization level. Any EkLine organization member can install the GitHub App on additional GitHub organizations. If a connected GitHub organization becomes inaccessible — for example, if someone uninstalls the app from that organization — a warning appears on the integrations page.
## GitLab
[Section titled “GitLab”](#gitlab)
Pull merge requests, issues, and repository files from GitLab into your documentation workflow. Reference GitLab content directly in your prompts to generate or update documentation from your GitLab projects.
**Use cases:**
* Generate a migration guide from changes in a merge request.
* Update documentation based on a completed issue.
* Create technical specs by referencing repository files and merge request discussions.
**Examples:**
```text
Create a changelog entry based on this GitLab merge request:
https://gitlab.com/your-org/platform/-/merge_requests/42
```
```text
Update the authentication docs based on the changes in
GitLab issue #215.
```
```text
Document the new API endpoints by referencing the files
changed in merge request !87.
```
The agent recognizes GitLab URLs automatically — paste a merge request or issue link and the agent fetches the details directly from your connected GitLab instance.
Organization-level access
GitLab connects at the organization level. Once a team member authorizes the connection, any organization member can use it through Docs Agent. The agent accesses content using the permissions of the account that authorized the connection.
## Slack
[Section titled “Slack”](#slack)
Turn support conversations, incident threads, and team discussions into structured documentation.
**Use cases:**
* Convert a support answer into a how-to guide.
* Document troubleshooting steps from an incident channel.
* Create FAQ entries from common customer questions.
**Example:**
```text
Create a troubleshooting guide based on this Slack thread:
https://workspace.slack.com/archives/C01234/p1234567890
```
The agent extracts the conversation, identifies the problem, and structures it into documentation format.
Create docs without leaving Slack
Use the [Slack bot](/agent/slack-bot) to @mention `@EkLine` directly in any channel or thread. The bot captures the conversation context and creates a draft you can review in EkLine.
## Notion
[Section titled “Notion”](#notion)
Pull product specs, design documents, and meeting notes into your documentation workflow.
**Use cases:**
* Transform product specs into technical documentation.
* Create user guides from design documents.
* Generate API docs from specification pages.
**Example:**
```text
Create API documentation based on the spec in this Notion page:
https://notion.so/your-workspace/api-spec-page-id
```
## Linear
[Section titled “Linear”](#linear)
Reference completed work to update documentation or generate release notes.
**Use cases:**
* Update docs when a feature ships.
* Generate release notes from a milestone.
* Create changelog entries from issue descriptions.
**Examples:**
```text
Update the authentication docs based on Linear ticket ENG-1234.
```
```text
Generate release notes for all issues in the v2.0 milestone.
```
The agent reads the issue title, description, and comments to understand what changed.
## Jira
[Section titled “Jira”](#jira)
Reference Jira issues the same way you reference Linear tickets.
**Use cases:**
* Update documentation based on completed stories.
* Generate release notes from a sprint or version.
* Create technical specs from epic descriptions.
**Example:**
```text
Update the deployment guide based on Jira ticket PROJ-5678.
Include the new configuration options mentioned in the ticket.
```
## Confluence
[Section titled “Confluence”](#confluence)
Pull existing documentation, runbooks, and internal knowledge into new docs.
**Use cases:**
* Migrate internal docs to your public documentation.
* Create user guides from technical runbooks.
* Reference architecture decisions in new documentation.
**Example:**
```text
Create a public deployment guide based on the internal runbook:
https://your-org.atlassian.net/wiki/spaces/ENG/pages/123456
```
## Google Drive
[Section titled “Google Drive”](#google-drive)
Connect Google Drive to give Docs Agent direct access to files and folders in your Drive. Unlike other integrations where you paste a URL, Google Drive lets the agent search, read, create, and organize files on your behalf.
**What the agent can do:**
| Action | Description |
| ------------------------ | ------------------------------------------- |
| Search files and folders | Find content by name or keyword |
| Read files | Download and read file contents |
| Create files | Create new documents or text files in Drive |
| Create folders | Organize content into folders |
| Upload files | Upload generated documentation to Drive |
| Move and rename | Reorganize files between folders |
| Delete files | Remove files from Drive |
**Use cases:**
* Pull a PRD from Drive and transform it into technical documentation.
* Save generated documentation directly to a shared Drive folder.
* Search Drive for existing specs before creating new docs.
* Organize generated files into team folders.
**Examples:**
```text
Create a feature overview based on the PRD in my Google Drive
called "Authentication Redesign Spec".
```
```text
Save the generated API reference to the "Engineering Docs"
folder in Google Drive.
```
```text
Search Google Drive for any existing documentation about
the payments API and update it with the latest changes.
```
Organization-level access
Google Drive connects at the organization level. Once a team member authorizes the connection, any organization member can use it through Docs Agent. The agent accesses files using the permissions of the account that authorized the connection.
## PostHog
[Section titled “PostHog”](#posthog)
Connect PostHog to give Docs Agent access to your product analytics, feature flags, and HogQL queries. The agent can pull insights from PostHog during documentation sessions to ground your content in real usage data.
**What the agent can do:**
| Action | Description |
| ------------------ | ----------------------------------------------- |
| Query insights | Read saved insights and analytics dashboards |
| Run HogQL queries | Execute HogQL queries against your PostHog data |
| Read feature flags | List and inspect feature flag configurations |
**Use cases:**
* Reference adoption metrics when writing release notes or feature documentation.
* Include feature flag details when documenting rollout procedures.
* Pull usage data to support decisions in architecture or migration guides.
**Examples:**
```text
Summarize the adoption metrics for the new onboarding flow
using the PostHog insights dashboard.
```
```text
Document the current feature flag configuration for
the "new-checkout" rollout, including rollout percentage
and targeting rules.
```
```text
Create a usage report based on the HogQL query for
weekly active users over the last 90 days.
```
### Connect PostHog
[Section titled “Connect PostHog”](#connect-posthog)
1. Go to **Settings > Organization > Integrations** in your EkLine dashboard.
2. Click **Connect** on the PostHog card.
3. Enter your PostHog personal API key. You can generate one from **PostHog > Settings > Personal API Keys**.
4. Select your PostHog region (US, EU, or enter a custom hostname for self-hosted instances).
5. Click **Connect** to activate the integration.
The personal API key starts with `phx_`.
Supported regions
PostHog offers four cloud regions — **US (Public)**, **US (Private)**, **EU (Public)**, and **EU (Private)**. If you run a self-hosted PostHog instance, select **Custom** and enter your hostname.
Organization-level access
PostHog connects at the organization level. Once a team member connects PostHog, any organization member can use it through Docs Agent. The agent accesses data using the permissions of the personal API key that the connecting team member provided.
## Combine multiple sources
[Section titled “Combine multiple sources”](#combine-multiple-sources)
Reference multiple integrations in a single prompt to create comprehensive documentation.
```text
Update the authentication docs based on:
- Linear ticket ENG-1234 (the feature implementation)
- This Slack thread where we discussed edge cases:
https://workspace.slack.com/archives/C01234/p1234567890
- The original spec in Notion:
https://notion.so/your-workspace/auth-spec
```
## Tips
[Section titled “Tips”](#tips)
Best practices
* **Reference exact URLs or IDs** — Paste a URL from a connected integration, and the agent automatically recognizes the service and fetches the content.
* **Verify access** — You can only pull content you have permission to view.
* **Add context** — Tell the agent what kind of documentation you need from the source.
* **Combine thoughtfully** — Multiple sources work best when they relate to the same topic.
# Prevent documentation drift
> Set up automatic drift detection and a weekly scheduled review so your documentation stays in sync as code changes.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact to request access.
Documentation falls behind code the moment a PR merges without a corresponding docs update. This is documentation drift — and it compounds until users file support tickets or teammates spend time figuring out what the code actually does today.
This guide sets up two safeguards that work together to catch drift automatically:
| Safeguard | When it runs | What it does |
| ------------------------- | -------------------- | ------------------------------------------------------------------------------------- |
| **Automatic PR review** | When a PR opens | Analyzes the diff and triggers a docs update when EkLine detects documentation impact |
| **Scheduled drift audit** | On a cadence you set | Reviews recent code activity and fixes the highest-priority undocumented change |
Together, they catch drift at the source (when a PR opens) and sweep for anything that slipped through (on a schedule).
## Before you begin
[Section titled “Before you begin”](#before-you-begin)
You need:
* An EkLine account with Docs Agent enabled.
* The [EkLine GitHub App connected](/agent/github-app-setup/) to at least one repository.
* At least one documentation path configured for your repository in **Settings → Organization → GitHub Integration**.
## Step 1: Verify automatic PR review is enabled
[Section titled “Step 1: Verify automatic PR review is enabled”](#step-1-verify-automatic-pr-review-is-enabled)
Automatic PR review is on by default. Confirm it is active for your repositories before continuing.
1. Go to your [EkLine Dashboard](https://ekline.io/dashboard).
2. Navigate to **Settings → Organization → GitHub Integration**.
3. Locate your documentation repository under **Documentation Repositories** and confirm the **Enable monitoring** toggle is on.
4. If the toggle is off, switch it on. EkLine saves the change immediately.
EkLine analyzes every non-draft pull request opened against a monitored repository and posts a comment when it detects documentation impact.
Tip
If this is a new installation of the GitHub App, toggle monitoring on for any repository you want to watch. Existing open PRs are not re-analyzed — the detection runs the next time a PR becomes ready for review.
## Step 2: See it detect a real change
[Section titled “Step 2: See it detect a real change”](#step-2-see-it-detect-a-real-change)
The fastest way to confirm automatic PR review works is to open a pull request that changes code with documentation impact.
1. Open a pull request against a monitored repository. Use a change that has a clear documentation impact — for example, adding a new API endpoint, renaming a configuration option, or removing a deprecated feature.
2. Make sure the PR is **ready for review** and not a draft.
3. Wait about 30 seconds. EkLine reads the diff, title, and description, then compares the changes against your existing documentation.
4. Check the PR comments. EkLine posts one of the following:
| Result | What it means |
| -------------------- | ------------------------------------------------------------------------------------------------------------ |
| No comment | Low confidence — the change likely does not affect documentation |
| Suggestion comment | Medium confidence — EkLine recommends a docs update and includes `@ekline-ai` so you can trigger it manually |
| Auto-trigger comment | High confidence — EkLine has already started a documentation session and links to a docs PR when ready |
If EkLine posts a comment, automatic drift detection is working.
Note
EkLine assesses each pull request once when it transitions to ready for review. Commits pushed after that point do not re-trigger the analysis. To re-assess, mention `@ekline-ai` manually in a new PR comment.
## Step 3: Set up a weekly scheduled drift audit
[Section titled “Step 3: Set up a weekly scheduled drift audit”](#step-3-set-up-a-weekly-scheduled-drift-audit)
The automatic PR review catches impact as PRs open. The scheduled drift audit catches changes that merged before EkLine was connected, or changes that fell below the automatic trigger threshold.
1. Click **Scheduled Agents** in the left navigation.
2. Click **New Agent**.
3. In the template picker, search for and select **Docs Drift Review**.
EkLine auto-fills the name and prompt:
```text
Audit the last 30 days of GitHub activity for customer-facing
changes that lack documentation, then fix the highest-priority gap.
```
4. Review the prompt. The default works for most teams. You can adjust the lookback window — for example, change `last 30 days` to `last 7 days` for a tighter weekly cadence — but leave the rest of the prompt as written.
5. Set the schedule to **Weekly** and pick a day and time. Monday morning is a common choice — it sweeps everything that shipped the previous week before your team starts new work.
6. Enable **Raise a pull request** so each run opens a PR with the documentation fix.
7. Optionally, enable **Send a Slack notification** and enter your docs channel name (for example, `docs-team`) to receive a run summary in Slack each week.
8. Click **Create Agent**.
The agent appears in your list and runs at the next scheduled time.
## Verify the setup
[Section titled “Verify the setup”](#verify-the-setup)
Confirm both safeguards are active:
* [ ] **Enable monitoring** is active for your documentation repository in **Settings → Organization → GitHub Integration**.
* [ ] A **Docs Drift Review** scheduled agent appears in **Scheduled Agents** with status **Enabled**.
To see the scheduled agent’s output before the first scheduled run, check back after the scheduled time. Click the chevron next to the agent to expand its run history, then click the run timestamp to open the full Docs Agent session.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Issue | Solution |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| EkLine never comments on PRs | Verify the GitHub App is installed on the repository and **Enable monitoring** is on. The agent skips draft PRs — convert them to ready for review. |
| Auto-trigger fired but no docs PR appeared | The agent may still be processing. Wait up to a minute, then check the PR comments for a link to the EkLine session. |
| Scheduled agent shows a failed run | Click the run timestamp in run history to open the full session. Common causes: the repository is no longer accessible, or there were no code changes in the audit window. |
| Docs PR from drift review is off-target | Comment on the docs PR and mention `@ekline-ai` with feedback. The agent resumes the session and pushes corrections. |
## Next steps
[Section titled “Next steps”](#next-steps)
* [Automatic PR review](/agent/automatic-pr-review/) — Understand the confidence tiers and what each detection level means.
* [Scheduled agents](/agent/scheduled-agents/) — Explore the full template library for recurring documentation tasks.
* [GitHub PR bot](/agent/github-integration/) — Trigger documentation sessions manually from any PR comment.
* [Create documentation](/agent/create/) — Generate READMEs, API references, and guides from your codebase.
# Docs Agent reference
> Supported file types, limits, troubleshooting, and frequently asked questions.
## Supported file types
[Section titled “Supported file types”](#supported-file-types)
Upload files to give the agent more context. Click the attachment icon in the chat panel and select your files.
### Documents
[Section titled “Documents”](#documents)
| Category | Formats | Max size |
| ---------------------- | --------------------------------------------------------------------------------------------------- | -------- |
| Text and markup | `.txt`, `.md`, `.markdown`, `.csv`, `.rst`, `.html`, `.htm`, `.adoc`, `.asciidoc`, `.tex`, `.latex` | 50 MB |
| Data and configuration | `.json`, `.yaml`, `.yml`, `.toml`, `.log`, `.sql`, `.ini`, `.config` | 50 MB |
| Office | `.doc`, `.docx`, `.xls`, `.xlsx`, `.ppt`, `.pptx`, `.rtf` | 50 MB |
| PDF | `.pdf` | 50 MB |
| Images | `.jpg`, `.jpeg`, `.png`, `.gif`, `.webp`, `.tiff`, `.tif`, `.bmp` | 50 MB |
### Code files
[Section titled “Code files”](#code-files)
| Language | Formats | Max size |
| ----------------------- | ---------------------------------------------------------------------------------------------- | -------- |
| Python | `.py`, `.ipynb` | 50 MB |
| JavaScript / TypeScript | `.js`, `.jsx`, `.ts`, `.tsx`, `.css` | 50 MB |
| JVM | `.java`, `.kt`, `.kts`, `.scala` | 50 MB |
| C family | `.c`, `.cpp`, `.cxx`, `.h`, `.hpp`, `.cs` | 50 MB |
| Systems and scripting | `.rs`, `.go`, `.rb`, `.php`, `.swift`, `.dart`, `.lua`, `.pl`, `.pm`, `.t`, `.m`, `.r`, `.rmd` | 50 MB |
| Shell | `.sh`, `.bash`, `.zsh` | 50 MB |
### Video
[Section titled “Video”](#video)
| Formats | Max size |
| -------------------------------------------------------- | -------- |
| `.mp4`, `.webm`, `.mov`, `.avi`, `.mpeg`, `.mpg`, `.ogg` | 500 MB |
### Processing notes
[Section titled “Processing notes”](#processing-notes)
* **Text-based PDFs** — The agent extracts text instantly.
* **Scanned PDFs** — The agent processes these with optical character recognition (OCR), which may take longer.
* **Images** — The agent sees the image content directly. You can use images as visual context or [insert them into your documentation](/agent/create/#from-screenshots-and-images) as files.
* **Code, data, and configuration files** — Content is extracted as plain text. Files larger than 500,000 characters are truncated with a marker indicating where the content was cut.
* **Video** — The agent transcribes and summarizes the content; processing time varies with length.
### Binary files in the editor
[Section titled “Binary files in the editor”](#binary-files-in-the-editor)
When the agent inserts an image into your repository, it appears as a placeholder in the editor. Binary files don’t preview inline, but the agent adds the correct markdown reference in the surrounding document. Binary files appear when you [create a pull request](/agent/update-review/#create-a-pull-request).
## Session history
[Section titled “Session history”](#session-history)
Each conversation with Docs Agent is a session, whether you start it in the editor, from a [GitHub pull request comment](/agent/github-integration/), or from a [Slack @mention](/agent/slack-bot). EkLine keeps your sessions so you can return to them later instead of starting over.
Sessions stay resumable for 90 days from your last activity. Each time you interact with a session, the 90-day window restarts, so active conversations stay available as long as you keep using them.
Resuming a session keeps its full context. The agent remembers earlier messages, uploaded files, and the documentation it generated. How you resume depends on where the session runs:
* **Editor** — Reopen the session from the sidebar and continue the conversation.
* **GitHub** — Mention `@ekline-ai` again on the same pull request. The agent resumes the existing session instead of starting a new one.
* **Slack** — Reply in the same thread with a follow-up `@EkLine` mention. The bot continues the same session.
After 90 days of inactivity, a session expires. When you try to resume an expired session, EkLine tells you the session is no longer available, and you can start a new session to continue your work.
## Limits
[Section titled “Limits”](#limits)
Upload limits
| Limit | Value |
| ------------------ | --------------------------- |
| Document file size | 50 MB per file |
| Video file size | 500 MB per file |
| Extracted text | 500,000 characters per file |
| Files per message | 20 |
| Session history | 90 days from last activity |
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
### Docs Agent doesn’t appear in the navigation
[Section titled “Docs Agent doesn’t appear in the navigation”](#docs-agent-doesnt-appear-in-the-navigation)
Docs Agent access is granted on request. Email **** with your organization name to request access.
### The agent doesn’t understand the repository structure
[Section titled “The agent doesn’t understand the repository structure”](#the-agent-doesnt-understand-the-repository-structure)
Be more specific in your prompt:
* Reference file paths: `"Look at src/api/auth.ts"`
* Mention the framework: `"This is a Next.js project using App Router"`
* Describe the architecture: `"API routes are in src/pages/api, components in src/components"`
You can also add this kind of context permanently through [custom instructions](#can-i-give-the-agent-context-about-my-organization).
### Generated content doesn’t match the documentation style
[Section titled “Generated content doesn’t match the documentation style”](#generated-content-doesnt-match-the-documentation-style)
The agent learns from your existing docs. If styles are inconsistent, results may vary.
Try:
* Reference a specific doc as an example: `"Match the style of docs/getting-started.md"`
* Be explicit about formatting: `"Use numbered steps, not bullet points"`
* Specify tone: `"Technical but approachable, similar to Stripe's docs"`
### Integration content isn’t loading
[Section titled “Integration content isn’t loading”](#integration-content-isnt-loading)
Verify that:
1. The integration is connected in **Settings > Organization > Integrations**.
2. You have access to the Slack channel, Notion page, or ticket.
3. The URL or reference ID is correct.
### Pull request creation fails
[Section titled “Pull request creation fails”](#pull-request-creation-fails)
Verify that:
* Your repository is connected to EkLine.
* You have write access to the repository.
* The branch you’re targeting exists.
* The PR title is at least 5 characters.
If the issue persists, contact ****.
### Video processing is slow or fails
[Section titled “Video processing is slow or fails”](#video-processing-is-slow-or-fails)
Video processing time depends on length. For a 10-minute video, expect 2 to 3 minutes of processing.
If processing fails:
* Verify that the file format is supported.
* Check that the file is under 500 MB.
* Try re-uploading the file.
## FAQ
[Section titled “FAQ”](#faq)
### What repositories can Docs Agent access?
[Section titled “What repositories can Docs Agent access?”](#what-repositories-can-docs-agent-access)
Repositories connected to your EkLine organization. Manage repository access in **Settings > Organization > GitHub Integration**.
### Does the agent modify files directly?
[Section titled “Does the agent modify files directly?”](#does-the-agent-modify-files-directly)
In the editor, no. The agent generates content that you review, edit, and then publish through a pull request.
When triggered from a [GitHub PR comment](/agent/github-integration/) or a [Slack @mention](/agent/slack-bot#automatic-pull-requests), the agent automatically opens a docs PR on your configured documentation repository. You still review and merge the PR before changes reach your main branch.
### Can I use Docs Agent for private repositories?
[Section titled “Can I use Docs Agent for private repositories?”](#can-i-use-docs-agent-for-private-repositories)
Yes. The agent respects your repository permissions and only accesses repositories you’ve connected and authorized.
### Can I give the agent context about my organization?
[Section titled “Can I give the agent context about my organization?”](#can-i-give-the-agent-context-about-my-organization)
Yes. Go to **Settings > Organization > Docs Agent** and add custom instructions. Use these to give the agent context it can’t infer from your code alone — for example, the purpose of each repository, how your documentation is organized, which versions to support, or company-specific conventions. The agent applies these instructions to every session for your organization. Click **Refresh Docs Agent Instructions** to apply changes. Any organization member can edit custom instructions up to 5,000 characters.
### How does the agent know my documentation style?
[Section titled “How does the agent know my documentation style?”](#how-does-the-agent-know-my-documentation-style)
The agent analyzes your existing documentation to understand patterns:
* Heading structure and hierarchy.
* Code example conventions.
* Terminology and voice.
* File organization and naming.
For best results, keep a consistent style in your existing docs. You can also use [custom instructions](#can-i-give-the-agent-context-about-my-organization) to specify preferences the agent can’t pick up from the codebase.
### What happens to uploaded files?
[Section titled “What happens to uploaded files?”](#what-happens-to-uploaded-files)
EkLine extracts content from uploaded files to inform the agent’s response. EkLine stores files securely and associates them with your session. EkLine does not share them with other users or organizations.
### Can I stop the agent or send messages while it works?
[Section titled “Can I stop the agent or send messages while it works?”](#can-i-stop-the-agent-or-send-messages-while-it-works)
Yes. The chat input button has three states: **Send**, **Stop**, and **Queue**. When the agent is working, click the Stop button to cancel the current turn, or type a follow-up and click the Queue button to send it after the current turn completes. See [Control the agent while it works](/agent/getting-started/#control-the-agent-while-it-works) for details.
### Can I use Docs Agent without creating a pull request?
[Section titled “Can I use Docs Agent without creating a pull request?”](#can-i-use-docs-agent-without-creating-a-pull-request)
Yes. You can copy content directly from the editor or download the generated files. The PR workflow is optional.
### How does Docs Agent select reviewers for pull requests?
[Section titled “How does Docs Agent select reviewers for pull requests?”](#how-does-docs-agent-select-reviewers-for-pull-requests)
The agent uses two sources to assign reviewers:
* **Default reviewers** — usernames your organization administrator configures in **Settings > Organization > Docs Agent**. The agent adds these reviewers to every PR it opens.
* **Auto-assign** — enabled by default, the agent identifies who triggered the session and adds them as a reviewer. For example, if someone requests documentation from Slack, the agent looks up their GitHub username. If the session started from a source PR, the PR author is added.
Bot accounts are automatically excluded. If the agent cannot find a reviewer, the PR is still created without one.
### How long can I resume a Docs Agent session?
[Section titled “How long can I resume a Docs Agent session?”](#how-long-can-i-resume-a-docs-agent-session)
Sessions stay resumable for 90 days from your last activity. Each interaction restarts the 90-day window, so active conversations remain available as long as you keep using them. See [Session history](#session-history) for how to resume a session from the editor, GitHub, or Slack.
## Get help
[Section titled “Get help”](#get-help)
For issues not covered here, contact **** with:
* A description of what you’re trying to do.
* The prompt you used.
* Any error messages you received.
* Screenshots if applicable.
# EkLine scheduled documentation agents
> Automate recurring documentation tasks — drift audits, tutorial gap analysis, SEO reviews, release notes, and more — with agents that run on a schedule you define.
Documentation drifts out of date the moment code ships. New features go undocumented, tutorials fall behind, and stale README files mislead users. Catching these problems manually is tedious and easy to forget.
Scheduled agents handle this for you. Each agent runs a prompt on a recurring cadence — hourly, daily, weekly, or monthly — and delivers the results as a pull request, a Slack message, or both. You set it up once, and EkLine keeps your docs accurate without ongoing effort.
[Scheduled Agents Demo](https://www.youtube.com/embed/56ygnpePseA?si=NoPSXqX8YkOfwAPf)
## What you can automate
[Section titled “What you can automate”](#what-you-can-automate)
EkLine provides pre-built templates that cover the most common documentation maintenance tasks. Each template is a proven prompt that the agent runs on every scheduled execution. You can also write your own prompt from scratch.
### Quality and accuracy audits
[Section titled “Quality and accuracy audits”](#quality-and-accuracy-audits)
These templates catch problems before your users do.
| Template | What it does |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Docs Drift Review** | Audits the last 30 days of GitHub activity for customer-facing changes that lack documentation, then fixes the highest-priority gap. |
| **Code Sample Review** | Verifies that code samples in your docs are accurate and runnable against the APIs and SDKs they demonstrate, then opens a PR fixing accuracy issues. |
| **Doc UI Accuracy Review** | Checks that your docs match the current frontend UI — labels, navigation paths, element placement — and opens a PR fixing UI drift. |
| **Image Alt Audit** | Scans documentation images for missing or low-quality alt text and fixes up to 20 images per run for accessibility compliance. |
| **README Review** | Audits your `README.md` against the current codebase and fixes inaccurate installation steps, dependencies, configuration, examples, or API references. |
### Content discovery and growth
[Section titled “Content discovery and growth”](#content-discovery-and-growth)
These templates find gaps and create new content.
| Template | What it does |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| **Tutorial Gap Review** | Analyzes your product, audience, and competitor docs to identify the most important missing tutorial or how-to guide, then writes it. |
| **Persona IA Review** | Reviews your docs from representative user personas and fixes the highest-ranked information architecture issue on their journey. |
| **Docs SEO Review** | Audits page titles, descriptions, headings, and internal links against your company marketing keywords, then fixes the highest-impact issue. |
| **FAQ Structured Data** | Adds or fixes FAQPage JSON-LD on FAQ documentation pages so they qualify for search engine rich results, capped at five file changes per run. |
### Reporting and communication
[Section titled “Reporting and communication”](#reporting-and-communication)
These templates keep your team informed without manual effort.
| Template | What it does |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Release Notes Generator** | Generates structured release notes from completed tickets and GitHub activity since the last release-notes update. |
| **Release Marketing Brief** | Drafts a Slack-ready brief of significant user-facing features that shipped in the last seven days, as raw material for marketing and CS teams. |
| **EkLine Work Report** | Generates a stakeholder-facing report of EkLine docs activity across all repos for the last seven days — what shipped, what is waiting, and what is open. |
| **Pylon Support Review** | Clusters recent Pylon support tickets by theme into a prioritized report of documentation gaps, delivered wherever you direct or inline in Slack. |
Tip
Most templates deliver results as both a pull request and a Slack message. The **Release Marketing Brief**, **EkLine Work Report**, and **Pylon Support Review** are Slack-only by default because they produce summaries rather than file changes.
## How it works
[Section titled “How it works”](#how-it-works)
Every scheduled agent follows the same lifecycle:
1. **You configure it** — Pick a template or write a custom prompt, set a schedule, and choose how to receive results.
2. **EkLine runs it** — At each scheduled time, EkLine creates a Docs Agent session and executes your prompt against the connected repository.
3. **You get the results** — Depending on your notification settings, the agent raises a pull request with its changes, posts a summary to Slack, or both.
4. **You review** — Open the pull request to review and merge, or click a run in the history to view the full agent session.
## Before you begin
[Section titled “Before you begin”](#before-you-begin)
You need:
* An EkLine account with Docs Agent enabled.
* At least one repository [connected to EkLine](/agent/github-app-setup/).
## Create your first agent
[Section titled “Create your first agent”](#create-your-first-agent)
1. Click **Scheduled Agents** in the left navigation, then click **New Agent**.
2. **Pick a template.** The template picker defaults to the first available template and populates the name and prompt for you. Search by name or description to find a template that fits your goal, or select **Custom agent** at the bottom to write your own prompt.
3. **Review the name.** The agent name appears in run logs and Slack messages. When you select a template, EkLine auto-fills the name — edit it to match your team’s naming convention if needed.
4. **Review and customize the prompt.** The prompt defines what the agent does on each run. Templates give a proven starting point that you can edit. If a template includes a highlighted `` placeholder, replace it with your value before saving.
5. **Set the schedule.** Select a frequency — hourly, daily, weekly, or monthly — a repeat interval, such as every 2 weeks, and the time of day. A preview shows the next five run times. All times display in your local timezone.
6. **Configure notifications.** Enable **Raise a pull request** to have the agent open a PR with its changes. Enable **Send a Slack notification** and enter a channel name (for example, `docs-team`) to receive a summary in Slack.
7. Click **Create Agent**.
The agent appears in your list and runs automatically at the next scheduled time.
### Templates that require input
[Section titled “Templates that require input”](#templates-that-require-input)
Three templates ask you to provide a value specific to your organization:
| Template | Required input | Example |
| ------------------------ | ---------------------------------- | ---------------------------------- |
| **Docs SEO Review** | Your company marketing website URL | `https://www.example.com` |
| **README Review** | Repository name | `my-org/my-repo` |
| **Pylon Support Review** | Where to deliver the report | `post to Slack channel #docs-team` |
The form prevents saving until you replace the `` placeholder with a real value.
### Write effective custom prompts
[Section titled “Write effective custom prompts”](#write-effective-custom-prompts)
If you select **Custom agent**, write a prompt that is self-contained and repeatable. The agent runs without human interaction, so include everything it needs.
* Release notes
```text
Generate release notes for all tickets completed since the
last release. Organize by Features, Improvements, and Bug
Fixes. Write for end users.
```
* Doc audit
```text
Review the docs/ directory for outdated content. Flag any
references to deprecated APIs or removed features. Create
a summary of what needs updating.
```
* README sync
```text
Check if the README reflects the current project structure
and dependencies. Update any outdated installation
instructions or configuration examples.
```
Prompt tips
* Be specific about the output format and audience.
* Reference file paths to focus the agent on relevant code.
* Include grouping or sorting instructions for generated content.
* Prompts can be up to 10,000 characters.
## Choose a schedule
[Section titled “Choose a schedule”](#choose-a-schedule)
The schedule picker supports four frequencies, each with a repeat interval. All times display in your local timezone.
| Frequency | Options | Example |
| ----------- | ------------------------------------------------------------------------------- | ----------------------------------------------- |
| **Hourly** | Repeat every 1 to 24 hours | Every 2 hours |
| **Daily** | Repeat every 1 to 30 days, select the time of day | Every other day at 9:00 AM |
| **Weekly** | Repeat every 1 to 12 weeks, select one or more days and the time | Every 2 weeks on Monday and Thursday at 9:00 AM |
| **Monthly** | Repeat every 1 to 12 months, select the day of the month from 1 to 28, and time | Every 3 months on day 1 at 9:00 AM |
Use **Repeat every** to create interval schedules such as bi-weekly or every other day. The preview under the picker shows the next five run times so you can confirm the schedule before saving.
Note
Monthly schedules cap at day 28 to avoid inconsistencies across months with different lengths. Interval schedules, such as every 2 weeks or every other day, keep their rhythm from the date you create the agent. Run times stay fixed to your local clock across daylight saving changes.
## Manage your agents
[Section titled “Manage your agents”](#manage-your-agents)
Each agent row shows its primary controls inline: the enable toggle, the **Run now** play icon, a **More actions** (⋯) menu, and the expand chevron. Secondary actions — **Skip next run**, **Edit**, and **Delete** — live in the **More actions** (⋯) menu.
### Run an agent immediately
[Section titled “Run an agent immediately”](#run-an-agent-immediately)
Click the play icon on the agent row to trigger a run right away — useful for testing a new prompt without waiting for the next scheduled time. The run appears in the agent’s run history, and the system counts the next scheduled run from this one.
### Skip the next run
[Section titled “Skip the next run”](#skip-the-next-run)
Open the **More actions** (⋯) menu on the agent row and select **Skip next run** to skip the next upcoming run. The run after it happens as scheduled. Selecting **Skip next run** again before the skipped time passes also skips the following run.
### Enable or disable an agent
[Section titled “Enable or disable an agent”](#enable-or-disable-an-agent)
Toggle the switch next to any agent to enable or disable it. Disabled agents keep their configuration but stop running until you re-enable them.
### Edit an agent
[Section titled “Edit an agent”](#edit-an-agent)
Open the **More actions** (⋯) menu on the agent row and select **Edit** to update the name, prompt, schedule, or notification settings. If you switch to a different template after editing the prompt, a confirmation dialog asks whether to replace your changes.
### Delete an agent
[Section titled “Delete an agent”](#delete-an-agent)
Open the **More actions** (⋯) menu on the agent row, select **Delete**, and confirm the deletion. Deleting an agent removes it permanently, but links to earlier editor sessions from run history remain accessible.
Caution
Deleting a scheduled agent cannot be undone.
## View run history
[Section titled “View run history”](#view-run-history)
Expand any agent row by clicking the chevron to see its recent runs. Run history displays the five most recent executions, sorted from newest to oldest.
Each run shows:
| Element | Description |
| ------------------ | -------------------------------------------------------------------------------- |
| **Status icon** | Green checkmark for succeeded, red cross for failed, yellow clock for running |
| **Timestamp link** | When the run started — click to open the Docs Agent session with the full output |
Clicking a run link opens the editor where you can review everything the agent did, including the generated content, files changed, and any pull requests raised.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Create documentation](/agent/create) — Generate READMEs, API references, and guides with custom prompts.
* [Update and review](/agent/update-review) — Keep documentation in sync with code changes.
* [Integrations](/agent/integrations) — Pull content from Slack, Notion, Linear, and more.
# Docs Agent Slack bot
> Create documentation drafts directly from Slack by @mentioning EkLine in any channel or thread.
Request access
Docs Agent is available to all plans, but we grant access on request. Contact **** to request access.
Create documentation without leaving Slack. @mention EkLine in any channel or thread, and the bot generates a draft you can review and edit in EkLine.
## Prerequisites
[Section titled “Prerequisites”](#prerequisites)
Before you begin, you need:
* An EkLine organization account.
* Slack workspace administrator access to install the app.
* Docs Agent access enabled for your organization.
## Connect your Slack workspace
[Section titled “Connect your Slack workspace”](#connect-your-slack-workspace)
1. Go to **Settings > Organization > Integrations** in your EkLine dashboard.
2. Find **Slack** in the integrations list.
3. Click **Connect**.
4. Allow EkLine to access your Slack workspace in the OAuth 2.0 popup.
5. Complete the Slack authorization flow.
6. Verify the integration shows as **Connected**.
Once connected, anyone in the Slack workspace can mention `@EkLine` to create documentation drafts.
## Create documentation from Slack
[Section titled “Create documentation from Slack”](#create-documentation-from-slack)
1. In any Slack channel or thread, type `@EkLine` followed by your request.
```plaintext
@EkLine create a troubleshooting guide based on this discussion
```
2. Follow the live progress message. A single message updates in place to show what Docs Agent is doing as it analyzes the conversation and drafts the documentation, which typically takes 10-30 seconds.
3. On the first response in a thread, Docs Agent adds a **View EkLine chat** button. Click it to open the session in EkLine, where you can review and edit the draft.
4. Read Docs Agent’s reply. When the agent finishes, the live progress message disappears and the agent posts its own reply directly in the thread, along with an expandable diff of the proposed changes.
5. Docs Agent automatically creates a pull request with the drafted changes and includes the PR link in its reply.
Reviewing the diff
The proposed changes appear as an expandable, collapsed-by-default attachment in the thread. Expand it to see the full diff without leaving Slack.
## Automatic pull requests
[Section titled “Automatic pull requests”](#automatic-pull-requests)
When you @mention EkLine in Slack, Docs Agent automatically opens a pull request with the drafted changes. This behavior **defaults to enabled** for all organizations.
Docs Agent includes the PR link in its Slack reply so you can review and merge the changes directly from GitHub.
### Disable automatic PRs
[Section titled “Disable automatic PRs”](#disable-automatic-prs)
If you prefer to review drafts in the editor before creating a PR manually:
1. Go to **Settings > Organization > Docs Agent** in your EkLine dashboard.
2. Under **Slack triggers**, turn off the **Automatically raise PRs from Slack requests** toggle.
3. The setting takes effect on the next Slack request. Existing sessions are unaffected.
Opt back in anytime
Turn the toggle back on to resume automatic PR creation from Slack.
## Context the bot captures
[Section titled “Context the bot captures”](#context-the-bot-captures)
The bot gathers context from the conversation to produce accurate documentation:
| Context type | What the bot captures |
| ---------------- | ----------------------------------------------------------------------- |
| Thread messages | All messages in the current thread |
| Channel messages | The last 10 messages before your @mention |
| File attachments | Images (JPEG, PNG, GIF, WebP), PDFs, and videos attached to the message |
| Reactions | Emoji reactions on messages |
Get better results
@mention the bot in threads with relevant discussion. The more context in the thread, the more accurate the generated documentation.
## Write effective prompts
[Section titled “Write effective prompts”](#write-effective-prompts)
The quality of your prompt determines the quality of the output.
| Instead of… | Try… |
| ---------------- | ------------------------------------------------------------------------- |
| “help with docs" | "Create a troubleshooting guide for the API timeout issue discussed here" |
| "document this" | "Write a how-to guide for the workaround Sarah described" |
| "make docs" | "Update the authentication docs based on the new flow we agreed on” |
**Include specific details:**
* Reference the type of documentation you need: tutorial, how-to guide, reference, troubleshooting.
* Name specific topics or features from the conversation.
* Mention existing documentation to update if applicable.
* Point to URLs or ticket IDs for more context.
## Troubleshooting
[Section titled “Troubleshooting”](#troubleshooting)
| Issue | Solution |
| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Bot does not respond | Verify the workspace connection in **Settings > Organization > Integrations**. Check that the bot has access to the channel. |
| ”Workspace not connected” error | Ask a workspace administrator to reconnect the integration in EkLine settings. |
| Draft does not match expectations | Give more specific instructions in your mention. Include the documentation type and key topics to cover. |
| Bot takes longer than expected | Complex requests may take longer. The bot notifies you if a request times out. |
| Bot responds but link is broken | Refresh the page and try the link again. If the issue persists, contact ****. |
## Next steps
[Section titled “Next steps”](#next-steps)
* [GitHub PR bot](/agent/github-integration/) — Trigger Docs Agent from pull request comments and code reviews.
* [Create documentation](/agent/create) — Generate READMEs, API references, and guides from your codebase.
* [Update and review](/agent/update-review) — Keep documentation in sync with code changes.
* [Integrations](/agent/integrations) — Connect Notion, Linear, Jira, and other tools.
# Update and review documentation
> Keep documentation in sync with code changes and get AI feedback on existing content.
Use update mode when documentation exists but needs changes. Use review mode to get feedback without modifying content.
## Update from tickets
[Section titled “Update from tickets”](#update-from-tickets)
When a feature ships or a bug is fixed, update documentation by referencing the ticket. The agent reads the ticket details and identifies which docs need changes.
**Works with:** Linear, Jira
* Basic update
```plaintext
Update the documentation based on Linear ticket ENG-1234.
```
* With context
```plaintext
ENG-1234 added rate limiting to the API. Update the
API reference with the new rate limit headers and
error responses.
```
* Multiple tickets
```plaintext
Update the authentication docs based on ENG-1234,
ENG-1235, and ENG-1236.
```
Tip
Adding context about what changed helps the agent make more accurate updates.
## Update from code changes
[Section titled “Update from code changes”](#update-from-code-changes)
Point the agent to code changes and it updates relevant documentation.
```plaintext
The login flow changed in the last commit. Update the
authentication guide to reflect the new OAuth
implementation in src/auth/.
```
```plaintext
We deprecated the /api/v1/users endpoint. Update the
API reference to mark it as deprecated and point to
the v2 replacement.
```
## Update specific sections
[Section titled “Update specific sections”](#update-specific-sections)
Target specific parts of a document instead of regenerating everything.
```plaintext
Update only the "Configuration" section in
docs/getting-started.md with the new environment
variables from .env.example.
```
```plaintext
Add a "Troubleshooting" section to the deployment guide
covering the three most common issues from our support
tickets.
```
This is useful when you want precise edits without affecting the rest of the document.
## Review documentation
[Section titled “Review documentation”](#review-documentation)
Get AI feedback on existing documentation without making changes. The agent analyzes your content and provides suggestions.
Tip
For automated style enforcement on every pull request, pair Docs Agent with [Docs Reviewer](/reviewer/quickstart/). The agent generates and updates content — the reviewer catches style violations, inconsistent terminology, and formatting issues before they merge.
### What the agent checks
[Section titled “What the agent checks”](#what-the-agent-checks)
| Aspect | What it looks for |
| ---------------- | ------------------------------------------------------------ |
| **Clarity** | Are instructions easy to follow? Is the language clear? |
| **Completeness** | Are steps missing? Are edge cases covered? |
| **Accuracy** | Does the documentation match the current code? |
| **Consistency** | Does terminology match other docs? Is formatting consistent? |
### Example prompts
[Section titled “Example prompts”](#example-prompts)
```plaintext
Review the getting started guide and suggest improvements
for clarity and completeness.
```
```plaintext
Review the API reference for the authentication endpoints.
Check if the examples still work with the current code.
```
```plaintext
Review docs/deployment.md from the perspective of a
developer who has never deployed this application before.
```
### Applying suggestions
[Section titled “Applying suggestions”](#applying-suggestions)
The agent provides feedback in the chat panel. You can:
1. Apply suggestions you agree with by asking the agent to make the change
2. Edit directly in the editor panel
3. Iterate by asking for more specific feedback
## Verify before publishing
[Section titled “Verify before publishing”](#verify-before-publishing)
### View changes
[Section titled “View changes”](#view-changes)
Enable **View All Changes** in the toolbar to see a diff of all modifications. Review each change before creating a pull request.
Look for:
* Unintended deletions.
* Formatting issues.
* Content that needs adjustment.
### Link validation
[Section titled “Link validation”](#link-validation)
The agent automatically validates links and email addresses in generated content. If it detects broken links, it regenerates the affected sections with corrections.
### Create a pull request
[Section titled “Create a pull request”](#create-a-pull-request)
When satisfied with the changes:
1. Click **Raise PR** in the toolbar.
The agent prefills a prompt in the chat panel — for example, `Open a pull request` or `Open a pull request for my-org/my-repo` when you have changes across multiple repositories.
2. Edit the prompt if you want to add instructions, then press **Enter** to send it.
3. The agent creates the pull request and responds in the chat with a link to the PR.
If your session spans multiple repositories, click the **Raise PR** dropdown to select a specific repository.
Note
Pull requests include both text and binary files. If the agent inserted images or screenshots during the session, those files commit alongside your documentation changes.
### Update an existing pull request
[Section titled “Update an existing pull request”](#update-an-existing-pull-request)
After a PR is open, you can push more changes to it:
1. Make further edits in the editor or ask the agent for more changes in the chat.
2. Click **Update PR** in the toolbar when new changes are ready.
The agent prefills a prompt like `Update pull request #42 with my latest changes`.
3. Edit the prompt if needed, then press **Enter**.
4. The agent commits and pushes your changes to the existing PR branch.
Tip
When your PR is already up to date, the toolbar shows a **View PR** link that opens the pull request on GitHub in a new tab.
## Next steps
[Section titled “Next steps”](#next-steps)
* [Create documentation](/agent/create) — Generate READMEs, API references, and guides from your codebase.
* [Scheduled agents](/agent/scheduled-agents) — Automate recurring doc tasks like drift audits and freshness checks.
* [Integrations](/agent/integrations) — Connect Slack, Notion, Linear, Jira, and other tools.
* [Set up automated review](/reviewer/quickstart) — Run EkLine Docs Reviewer in your CI/CD pipeline to catch issues before they merge.
# EkLine changelog
> Stay up to date with the latest improvements and new features across EkLine products.
What’s new in EkLine. We publish monthly updates covering new features and improvements across Docs Reviewer and Docs Agent.
***
## July 2026
[Section titled “July 2026”](#july-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent)
**Flexible schedules for scheduled agents** — Set scheduled agents to repeat on interval-based cadences such as every other day, twice a week, or every two weeks. Select multiple weekdays for a single agent, and rely on timezone-aware run times that hold through daylight saving changes. The schedule picker previews your next five runs, and you can run an agent immediately or skip its next run. [Configure scheduled agents](/agent/scheduled-agents)
**Faster documentation PR dashboard** — The dashboard now renders immediately from saved data. It then loads live pull request details in the background, removing the multi-second delay when you open it on larger accounts.
**More complete PR tracking** — The dashboard now includes documentation pull requests recovered automatically even when they have no linked session. It also filters out unrelated automated pull requests such as dependency updates, so the list shows only EkLine’s documentation work.
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes)
* Fixed the editor preview crashing in some sessions.
* Fixed dialogs continuing to intercept clicks after you closed them, which could leave the app unresponsive until you refreshed the page.
* The @EkLine Slack bot now responds only when you mention it directly, so it no longer replies to other messages in a thread it has joined.
***
## June 2026
[Section titled “June 2026”](#june-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent-1)
**Typo-tolerant @EkLine mentions** — Docs Agent now responds to `@EkLine` mentions in GitHub and GitLab comments even when someone misspells or formats the handle incorrectly, so a typo no longer results in a silent no-op.
**Automatic merge requests on GitLab** — When Docs Agent flags a GitLab merge request as high-confidence for documentation changes, it now opens a documentation merge request automatically, matching the existing GitHub pull request flow. [Learn more](/agent/automatic-pr-review)
**Live progress in Slack** — The @EkLine Slack bot shows a live status indicator while it works on your request, so you can see it is making progress before the response arrives. [Set up the Slack bot](/agent/slack-bot)
**View PR for merged pull requests** — When a documentation pull request is already merged and has no new changes, the editor shows a **View PR** button instead of prompting you to raise a duplicate.
**Attach up to 20 files per message** — The chat panel now accepts up to 20 attachments per message and warns you when files exceed the limit instead of dropping them silently. [Supported file types](/agent/reference#supported-file-types)
**Slack thread responses** — The @EkLine Slack bot streams live progress in a single self-updating message, posts Docs Agent’s own reply with an expandable diff, and adds a **View EkLine chat** button on the first response. Follow-up mentions in that thread continue the same session, so the agent keeps context across messages. [Set up the Slack bot](/agent/slack-bot)
**Session reuse on PR comments** — Replying to a pull request comment Docs Agent created continues the existing session instead of starting a new one.
**90-day session history** — Resume Docs Agent sessions for up to 90 days, up from 30. [Learn more](/agent/reference/#session-history)
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes-1)
* Fixed Docs Agent posting duplicate comments on a GitLab merge request, where a medium-confidence review note could trigger itself.
* Fixed Docs Agent occasionally showing a raw JSON object instead of a readable summary when assessing whether a pull request needs documentation.
* Fixed the Docs Reviewer flagging the `https` scheme inside a URL in document frontmatter as a spelling issue.
* Only authorized project members can now trigger Docs Agent from GitLab merge request comments.
* Fixed the Docs Reviewer flagging keys inside document frontmatter when the file started with a byte order mark (BOM).
***
## May 2026
[Section titled “May 2026”](#may-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent-2)
**GitLab automatic MR review** — Docs Agent monitors your GitLab merge requests and detects when documentation needs updating, matching the existing GitHub PR review feature. [Learn more](/agent/automatic-pr-review)
**HubSpot integration** — Connect HubSpot from the integrations page to give Docs Agent access to your customer-facing content. [Set up integrations](/agent/integrations)
**Organization memory** — Docs Agent remembers context about your repositories and conventions across sessions, so your whole team benefits from shared knowledge.
**Style review before PR creation** — Docs Agent runs a documentation style check before creating pull requests, catching formatting and tone issues before human review.
**Mark session as done** — Mark completed sessions from the sidebar menu to keep your workspace tidy. The sidebar hides done sessions by default, and you can toggle them back into view.
**Agentic PR workflow** — Click **Raise PR** or **Update PR** in the editor, and Docs Agent handles the entire process through the chat. It writes meaningful commit messages and detects existing PRs before creating duplicates.
**Real-time PR status** — Track documentation PR state — open, merged, or closed — directly in the editor toolbar with live webhook-driven updates from GitHub and GitLab.
**Session links in PRs** — Documentation PRs created by Docs Agent include a link back to the editor session that generated them, so reviewers can see the full context.
**Automatic diff view** — Sessions open with the diff view enabled by default when documentation changes exist, so you see proposed edits immediately.
**Smarter session titles** — Sessions initiated from Slack and other triggers now generate descriptive titles instead of showing the raw first message.
**Improved GitLab @mentions** — @mentioning Docs Agent in GitLab merge requests now supports reactions and editor replies, matching the GitHub experience.
**Pylon support review template** — A new scheduled agent template that reviews Pylon support tickets to identify documentation opportunities. [Configure scheduled agents](/agent/scheduled-agents)
**Chat-driven pull requests** — Creating and updating documentation pull requests now happens through the chat panel. Click **Raise PR** or **Update PR** and the agent prefills a prompt you can edit before sending, giving you more control over commit messages and PR descriptions. [Learn more](/agent/update-review#create-a-pull-request)
**PR analysis confidence** — GitHub-triggered sessions now show a colored confidence badge in the sidebar indicating how likely a PR requires documentation changes.
**Dashboard PR tracking** — Documentation PRs created by Docs Agent appear on the dashboard with reviewer assignments, diff stats, and review state, so you track docs work alongside code changes.
**Session initiator badges** — Sessions in the sidebar show who started them, with name badges for Slack-triggered sessions and source labels for GitHub-triggered ones.
**Expanded file upload support** — Upload code files, data files, and configuration files alongside documents and images in the chat panel. The agent now accepts 67 file types including `.json`, `.yaml`, `.py`, `.ts`, `.go`, `.rs`, and more. [Supported file types](/agent/reference#supported-file-types)
**Automatic PRs from Slack** — Slack-triggered sessions now create documentation pull requests automatically, so you get a ready-to-review PR without switching to the editor. Disable per-organization in **Settings > Organization > Docs Agent**. [Set up the Slack bot](/agent/slack-bot)
**Credit badge** — Embed a “Maintained by EkLine” credit on your documentation site using a lightweight web component or static SVG badge. Supports automatic light and dark theme switching and works with all major documentation frameworks. [Embed the badge](/credit)
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes-2)
* Fixed GitHub repository deletions not persisting when saving integration settings.
* Fixed a brief “feature not available” flash when loading pages with feature flags.
* Fixed search modal disappearing when navigating between pages on the documentation site.
* Fixed blank onboarding page when the sign-up link did not include an email parameter.
***
## April 2026
[Section titled “April 2026”](#april-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent-3)
**Custom instructions** — Give Docs Agent context about your repositories, documentation structure, and company conventions in **Settings > Organization > Docs Agent**.
**GitLab integration** — Connect GitLab to let Docs Agent read merge requests, issues, and repository files when generating or updating documentation. [Set up integrations](/agent/integrations)
**Multiple GitHub organizations** — Connect more than one GitHub organization to a single EkLine organization. Manage all connected organizations from the integrations page.
**File attachments in Slack** — Attach files directly in Slack when chatting with the @EkLine bot to give the agent more context for documentation tasks. [Set up the Slack bot](/agent/slack-bot)
**Session rename** — Rename sessions directly from the sidebar by double-clicking the title or clicking the edit icon.
**Stop and queue messages** — Stop the agent mid-response and queue follow-up messages while it works, so you stay in control of the conversation.
**Session time groups** — The sidebar groups sessions by Today, Yesterday, Previous 7 Days, and Previous 30 Days for faster navigation.
**Session source filter** — Filter the sessions sidebar by source — EkLine editor, GitHub, Slack, or Scheduled — to find conversations faster.
**Customizable scheduled agent templates** — Select from 12 predefined templates when creating scheduled agents, then edit the prompt and toggle actions like raising a PR or sending a Slack notification. [Configure scheduled agents](/agent/scheduled-agents)
**PR reviewer settings** — Configure default reviewers and auto-assign behavior for documentation PRs in **Settings > Organization > Docs Agent**.
**GitLab MR comments** — @mention Docs Agent directly in GitLab merge request comments for context-aware responses.
### Docs Reviewer
[Section titled “Docs Reviewer”](#docs-reviewer)
**Review on open and save settings** — Control when automatic reviews run in VS Code with the new `ReviewOnOpen` and `ReviewOnSave` settings. Disable either to review only on demand.
**AI false-positive filtering** — Toggle AI-based false-positive filtering in VS Code with the `AiFalsePositiveFiltering` setting to reduce noise in review results.
**AI rules for repo-wide scans** — Control whether AI-powered rules run during full-repository scans in VS Code with the `EnableAiRulesForRepoWideScans` setting.
**Per-repository review rules** — Configure which pull requests trigger automatic reviews on a per-repository basis. Set target branch filters, ignore patterns, author lists, and file filters in **Settings > Organization > GitHub Integration** (select a repository to configure its review rules).
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes-3)
* Fixed file uploads failing when the server returned a redirect.
* Fixed clicking inside a session rename input unexpectedly navigating away.
* Inaccessible GitHub repositories now show a warning on the integrations page instead of failing silently.
***
## March 2026
[Section titled “March 2026”](#march-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent-4)
**Automatic PR review** — EkLine now monitors your pull requests and automatically detects when documentation needs updating. Depending on confidence, it stays silent, posts a suggestion, or creates a docs PR for you. [Learn more](/agent/automatic-pr-review)
**Google Drive integration** — Connect Google Drive to give Docs Agent access to your documentation stored in Drive. [Set up integrations](/agent/integrations)
**Scheduled agents** — Automate recurring documentation tasks on a cron schedule. Any organization member can create and manage scheduled agents. [Learn more](/agent/scheduled-agents)
**File attachments in chat** — Attach PDFs, Word documents, spreadsheets, and other files directly in the chat panel to give the agent additional context when generating documentation. [Supported file types](/agent/reference#supported-file-types)
**PDF native rendering** — Uploaded PDFs now display as native document blocks in the editor instead of generic attachments.
**Smarter PR line comments** — When you @mention Docs Agent on a specific line in a pull request, it now sees the exact line range and diff context for more precise responses.
**Screenshot insertion** — Upload screenshots and images, and the agent inserts them directly into your documentation with appropriate markdown references. [Learn more](/agent/create#from-screenshots-and-images)
**Faster session startup** — Organizations with large repositories experience up to 2x faster session workspace setup.
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes-4)
* Undo and redo now work correctly in the editor.
***
## February 2026
[Section titled “February 2026”](#february-2026)
### Docs Agent
[Section titled “Docs Agent”](#docs-agent-5)
**Slack bot** — Create documentation drafts without leaving Slack. @mention `@EkLine` in any channel or thread. [Set up the Slack bot](/agent/slack-bot)
**Unified Slack connection** — Connect Slack with a single authorization instead of two.
**Create pull requests from the editor** — Click **Raise PR** in the editor toolbar to create a GitHub pull request directly from your draft.
### Docs Reviewer
[Section titled “Docs Reviewer”](#docs-reviewer-1)
**AI suggestions in VS Code** — Get AI-powered writing suggestions as you write.
### Bug fixes
[Section titled “Bug fixes”](#bug-fixes-5)
* Fixed crash when linting large documentation sets in VS Code.
* Diagnostics now clear correctly when no issues are found.
* Default documentation path changed to workspace root for better compatibility.
***
Questions or feedback? Contact .
# Add the "Maintained by EkLine" credit
> Embed the EkLine credit on your documentation site. Find the snippet for your framework and paste it.
Find your docs framework below, copy the snippet, and paste it into your site. No account or API key required — the credit is a free hosted asset that adapts to your site’s theme automatically.
## Preview
[Section titled “Preview”](#preview)
The credit comes in two forms. The **web component** inherits your site’s font and color, so it blends in with any theme. The **SVG badge** is a fixed-style image for platforms that strip scripts.
Light background
Dark background
## Use an AI agent
[Section titled “Use an AI agent”](#use-an-ai-agent)
If you use an AI coding assistant, paste this prompt to add the credit automatically:
```text
Add the "Maintained by EkLine" credit to the footer of the documentation site.
For framework-specific instructions, fetch https://docs.ekline.io/credit/
Use the web component: load https://ekline.io/v1/credit.js as an async
script, then place in the site footer.
Detect which docs framework this project uses and follow its conventions
for adding a global script and footer element.
If the platform strips
```
Reference it on any page with ``. If Snippets aren’t available on your plan, use the [badge option](#markdown-only-platforms) instead.
* More
**Nextra**
theme.config.tsx
```tsx
export default {
head: ,
footer: { content: },
};
```
***
**VuePress**
.vuepress/config.js
```js
module.exports = {
head: [
['script', { src: 'https://ekline.io/v1/credit.js', async: true }],
],
};
```
Add `` in your footer component.
***
**Plain HTML**
```html
```
## Markdown-only platforms
[Section titled “Markdown-only platforms”](#markdown-only-platforms)
Platforms that strip `