🎬 Jev Docs Agent

Describe the goal. Get the video, the screenshots and the user guide.

An open-source, goal-driven agent that walks through any web app in a real browser, records every task as a walkthrough video, and turns the recordings into polished user documentation — driven from Claude Desktop.

Quick start · Use cases · How it works · Alternatives · vs. demo platforms · Claude Desktop · Roadmap · Contributing

A real recording: the agent was only told "Order confirmation page shows 'Thank you for your order!'" — it planned every click.

✨ Why this exists

Product walkthroughs, help-center articles and test evidence all need the same thing: someone clicking through the app, recording it, taking screenshots, and writing it up — and doing it all again after every UI change.

Jev Docs Agent does that work for you:

- name: checkout
  goal: "Order confirmation page shows 'Thank you for your order!'."

That's a complete test case. The agent opens a browser, figures out the clicks, records an HD video with a visible cursor, captures a screenshot after every step, and hands the recording to Claude to write the guide. When the UI changes, you re-run it — no selectors to fix, no scripts to maintain.

🎯 Goal-driven

Say what finished looks like. Jev decides each click from the live page — buttons can move, get renamed or restyled and the goal still works. Hints are optional.

🎥 Evidence by default

Every run produces a .webm video, a screenshot per action, an actions.json trail of every decision, and a pass/fail report.

📚 Docs, not just videos

Claude turns recordings into how-to guides, quick-starts and FAQs — exported as one HTML page (→ PDF) or a zip with MP4s.

💬 Runs from a chat

20 MCP tools let Claude Desktop create projects, write goals, record, debug failures and write docs. No YAML needed.

🔐 Bring any login

Credentials are supplied, never stored in config: per-project .env, role profiles (admin / viewer), or docker -e in CI.

💸 Very low cost

Jev answers in typed decisions, not prose. The 5-video example below estimated ~33 Jev calls ≈ $0.01.

Related MCP server: chromeboost

🧭 Use cases

• Technical writers / docs teams — keep screenshots and steps current without re-shooting everything by hand.

• Product & growth teams — produce demo clips and onboarding content without a video tool subscription.

• QA & test engineers — express tests as goals, get evidence for free, stop maintaining brittle selectors.

• Founders & small teams — get a help center and a smoke test suite from the same few lines of YAML.

• Developers — script it from the CLI or CI with Docker; everything is plain files.

🆚 How it compares

Jev Docs Agent is an open-source, self-hosted alternative that sits between demo builders, documentation tools and test automation — it does a useful part of each, from one goal definition.

🎞️ An open-source alternative to interactive demo platforms

Demo platforms are built for go-to-market teams: a person captures the product, the platform turns it into an interactive tour or sandbox, and tracks how buyers engage. Jev Docs Agent automates the other half — an AI agent captures every flow by itself and produces videos, guides and a pass/fail result, again on every release.

→ Full breakdown: Jev Docs Agent vs. interactive demo platforms — feature matrix, platform-by-platform notes, a release workflow that uses both, and a decision guide.

Use it instead of…

• Storylane / Supademo / Arcade / HowdyGo — when the deliverable is walkthrough videos and written guides of real flows, regenerated on every release, rather than hand-built interactive tours. Keep a demo platform for clickable, branching tours, lead capture and buyer analytics.

• Navattic / Consensus / Reprise / Demostack — not as a replacement: they own ABM, buyer intent and sandboxes. Use the agent to produce the underlying videos and to flag which demos went stale after a release.

• Scribe / Tango — when you want the capture done for you: nobody has to click through the app.

• Manual testing — for repeatable happy-path checks and UAT evidence; keep humans for exploratory testing and judgment calls.

• Playwright / Cypress scripts — for smoke tests and flows that break often because of UI churn. Keep coded tests where you need exact assertions, data setup and millisecond-level reliability in CI. The two work well together: this project is built on Playwright.

Honest limits. Goal-based checks are judged visually by a model, so they are excellent at "did the flow work?" and weaker at "is this number exactly 42.17?". It's not a load-testing or security-testing tool.

⚙️ How it works

flowchart LR
    G["🎯 Goal<br/><i>'Order confirmation<br/>page is shown'</i>"] --> L
    subgraph L["Recording loop (per step)"]
        direction TB
        S["👀 Read the page<br/>elements, text, popups"] --> J["🧠 Jev decides<br/>next element · value<br/>done? · confidence"]
        J --> A["🖱️ Playwright acts<br/>click · type · choose · upload"]
        A --> C{"Stuck or unsure?"}
        C -- yes --> K["🧭 Claude coach<br/>looks at a screenshot,<br/>gives one tip"] --> S
        C -- no --> S
    end
    L --> O["📦 video.webm · step_N.png<br/>actions.json · run_report.md"]
    O --> D["📝 Claude writes the guide"] --> E["📤 HTML · PDF · ZIP · MP4"]

Jev is TypeSafe AI's System One model: instead of writing prose it returns typed decisions with calibrated confidence. Every step the agent asks Jev several structured questions at once — which element next? what to type? did the last action work? is the goal done? — so it's fast, cheap and knows when it's unsure. When it is unsure, a Claude coach looks at a screenshot and gives one concrete tip. Safety rails sit around all of it:

• 🚫 forbid_labels — buttons the agent may never click (payments, delete, sign out) unless a video explicitly allows them.

• 🔒 Secrets stay secret — passwords come from env files, are typed into fields but never written to logs, actions.json or tool replies.

• ⏱️ Budgets — max steps, max wait, stall detection and loop detection on every video.

• ✅ Honest "done" — a video only passes after at least one action and a confident goal check.

🚀 Quick start

Prereqs: Docker (or Python 3.12) and an OpenRouter key (or a TypeSafe key). The example uses Sauce Demo, a public test shop.

git clone https://github.com/kaivalpatel6350/jev-docs-agent.git && cd jev-docs-agent
cp .env.example .env                                    # add OPENROUTER_API_KEY
cp projects/swaglabs/.env.example projects/swaglabs/.env  # Sauce Demo's public test login

docker build -t jev-docs-agent .

docker run --rm -v "$PWD/projects:/app/projects" \
  --env-file .env jev-docs-agent \
  python agent.py videos --project swaglabs

python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
playwright install chromium

python agent.py videos --project swaglabs

In about two minutes you'll have five videos and a report in projects/swaglabs/out/:

Then write and export the docs — from Claude Desktop (below) or the CLI:

python agent.py docs   --project swaglabs          # Claude writes the guides (uses your OpenRouter key)
python agent.py export --project swaglabs --mp4    # one HTML guide + a zip with MP4s

👉 See a generated result: docs/example-swag-labs-guide.md

💬 Drive it from Claude Desktop (MCP)

The MCP server lets Claude Desktop do everything — including writing guides.yaml for a brand-new app.

1. Build the image, then 2. merge this into ~/Library/Application Support/Claude/claude_desktop_config.json (Windows: %APPDATA%\Claude\claude_desktop_config.json) and restart Claude Desktop:

{
  "mcpServers": {
    "docs-agent": {
      "command": "docker",
      "args": ["run", "-i", "--rm",
               "-v", "/ABSOLUTE/PATH/TO/jev-docs-agent/projects:/app/projects",
               "--env-file", "/ABSOLUTE/PATH/TO/jev-docs-agent/.env",
               "-e", "HOST_PROJECTS_DIR=/ABSOLUTE/PATH/TO/jev-docs-agent/projects",
               "jev-docs-agent"]
    }
  }
}

3. Just ask:

"Create a docs project for https://app.acme.com. Make videos for signing in, creating an invoice and exporting a report. Record them, fix anything that fails, then write a how-to guide and export it as HTML and MP4."

"Here's our user manual (attached) — make a video for every how-to in it and group them into guides."

"Record the settings videos as the admin profile, then compare with the viewer profile."

When Claude Desktop writes the docs itself (get_doc_brief → save_doc), no Claude API key is needed — only Jev's key is used for recording. Every edit to guides.yaml keeps a .bak.

📝 Writing goals

app_url: https://www.saucedemo.com
forbid_labels: [Logout, Reset App State, Delete Account, Purchase]
test_data:
  username: ${LOGIN_USERNAME}        # secret → supplied from .env / docker -e
  password: ${LOGIN_PASSWORD}
  first_name: Jane                   # plain demo values Jev may type

videos:
  - name: login
    goal: "Signed in: the Products page (inventory list) is shown."
    start_path: /

  - name: checkout
    goal: "Order confirmation page shows 'Thank you for your order!'."
    start_after: login               # reuse the signed-in session
    start_path: /inventory.html
    hints:                           # optional — only where Jev needs help
      - "Fill First Name, Last Name, Zip/Postal Code from test data"

docs:
  - name: shopping-guide
    type: how-to guide
    audience: new customers
    videos: [login, checkout]

Tips: make goals verifiable ("the list shows INV-001 as Sent" beats "create an invoice"), keep one task per video, use demo accounts and synthetic data — screenshots are sent to the model.

🔐 Test logins

guides.yaml only names variables; values are supplied separately, so one project runs against any account or environment. Precedence: docker -e / shell → .env.<profile> → project .env → root .env.

Pick per run: run_videos(profile="admin"), --profile admin, or -e LOGIN_PROFILE=admin.

🧰 CLI reference

python agent.py plan    --project <name>                  # free: validate config, credentials, run order, cost
python agent.py videos  --project <name> [--only a,b] [--profile admin]
python agent.py docs    --project <name> [--only a] [--dry]   # Claude writes docs (--dry: build requests only)
python agent.py improve --project <name> [--only a]       # Claude rewrites failed goals/hints and re-records
python agent.py export  --project <name> [--only a] [--mp4]

agent.py              recording loop (Jev + Playwright), docs, improve, export CLI
mcp_server.py         20 MCP tools for Claude Desktop
exporter.py           HTML guide / ZIP / MP4 packaging
projects/<name>/
  guides.yaml         app_url, test_data, forbid_labels, videos (goals), docs
  .env, .env.<role>   test logins (git-ignored)
  out/                videos/<video>/{video.webm, step_N.png, actions.json}, docs/, exports/, run_report.md

❓ FAQ

Jev is TypeSafe AI's first public System One model — built for decisions inside software rather than chat. You send it structured questions (Choice, Noul, Score) and get typed answers with calibrated confidence. That makes it a good fit for a browser agent that needs to pick one element out of hundreds, many times per video, cheaply. It's available through the TypeSafe API and OpenRouter.

Recording only needs Jev. Claude is used for the optional coach (when Jev is stuck), for improve, and for writing docs from the CLI. If you use Claude Desktop, it writes the docs itself through MCP. One OpenRouter key covers Jev and Claude.

python agent.py plan estimates it before you run anything. The Sauce Demo example estimated ~33 Jev calls (≈ $0.01). Coach calls and doc writing with Claude cost more than Jev calls; with Claude Desktop writing the docs they come out of your Claude plan.

Any app a browser can open. Username/password logins work out of the box; the session is reused across videos. SSO redirects usually work if the test account doesn't need MFA. MFA codes and CAPTCHAs are not solved — use a test account without them, or a test environment that disables them.

Everything runs on your machine or your own Docker host; outputs are plain files. Page text and screenshots are sent to the model providers you configure (TypeSafe / OpenRouter / Anthropic), so use demo accounts and synthetic data. Passwords are never written to logs, actions.json or MCP replies — but if your app prints a secret on screen, it will appear in screenshots.

That's what Playwright records. export --mp4 (or "export as mp4") converts them to H.264 MP4 for PowerPoint, Confluence, Notion or any player.

Yes — docker run … python agent.py videos --project <name> exits after writing run_report.md and actions.json per video, with credentials from -e variables. Fail the build by checking each video's status.

🗺️ Roadmap

→ Full plan with designs, status and effort: ROADMAP.md

💡 Have an idea?

This project is shaped by its users. Share it in Ideas, 👍 the issues you want most — priorities follow demand.

🤝 Contributing

Contributions of every size are welcome — ideas, bug reports, example projects against public demo apps, docs and code.

• 🌱 New here? Try a good first issue.

• 📖 Read CONTRIBUTING.md for setup, testing and the PR checklist.

• 🔐 Never commit .env files, real credentials or recordings of private apps.

• 🤗 Please follow the Code of Conduct.

📄 License

MIT © 2026 Kaival Patel. Jev and TypeSafe are trademarks of TypeSafe AI; Claude is a trademark of Anthropic; Storylane, Navattic, Supademo, Arcade, HowdyGo, Consensus, Reprise, Demostack, Scribe, Tango and Guidde are trademarks of their respective owners and are mentioned only for comparison. This project is not affiliated with any of them. Sauce Demo is a public demo site by Sauce Labs.

If this saves you a day of screenshots, give it a ⭐

jev · typesafe-ai · system-one · ai-agent · browser-automation · playwright · mcp · claude-desktop · documentation-generator · walkthrough-videos · e2e-testing · no-code-testing · supademo-alternative · storylane-alternative · arcade-alternative · navattic-alternative · interactive-demo · scribe-alternative · test-automation · open-source