# Htvag Agent — the complete feature reference

Canonical page: https://agent.htvag.online/features · Markdown mirror: https://agent.htvag.online/features.md

Generated from the same live data the product page renders. Plain markdown, written to be fetched by an agent or pasted into a model as context.

Htvag Agent is a collection of tools around one autonomous agent. The coding agent reads and edits your repository and verifies its own work; an always-on assistant keeps local memory, runs scheduled tasks and answers the messages you choose; PC control lets it drive your own desktop; and Htvag Editor cuts video from a prompt. The same account covers the desktop app, the CLI, the browser and the Android chat.

## Key facts

- **Runs on:** Windows 10/11 · Linux
- **Also available as:** CLI · browser chat · browser build
- **Free plan:** 5 credits/day + up to 15 from ads
- **Your code:** Stays on your machine

## The coding agent

The core of the product: a real agent loop with a completion gate, the tools a human engineer uses, and the safety rails around them.

### The loop

- **Outcome-first agent loop** — You describe the result you want, not the steps. The agent inspects the repository, plans, edits real files, runs the build and the test suite, reads what failed, and re-plans until the outcome holds.
- **The completion gate** — Before a turn is allowed to end, it checks three things: open todos, files written but never built or tested, and a reply that hands the work back to you. Any of those push the agent to continue instead of reporting a half-finished job as done.
- **Streamed everything** — Reasoning, tool calls, edits and diffs arrive live in the app while the work happens — you watch the agent build the thing rather than waiting on a spinner.
- **Context management** — Stale tool output is trimmed first, and past roughly 75% of the model's window the older half of the transcript is summarized by the fast model — with the split snapped so a tool result is never orphaned from its call. Long sessions keep going instead of dying mid-task.

### Tools it works with

- **File tools with workspace confinement** — read_file, write_file, edit_file, list_dir, glob and grep — precise string edits, codebase-wide search, and every path confined to the folder you opened, symlinks included.
- **A persistent shell** — One long-lived shell per session, so cd, exported variables and activated environments survive between commands. Long-running commands run in the background and can be read or killed.
- **A real browser** — The agent can open a page and look at its own render as a screenshot — including a viewport mode that resizes the window to check a mobile layout or match a design's aspect ratio. The full-page image is saved to disk for you; the model gets a viewport JPEG.
- **Web search and fetch** — It searches the web and fetches documentation pages when it needs current information. Private and loopback addresses are refused.
- **Images and screenshot-to-code** — Attach a screenshot, mockup or design file and the agent builds against it, then compares its own render with the reference before calling it done.
- **Checkpoints and revert** — Every run records the pre-edit state of the files it touches, so a run that went the wrong way can be reverted from the UI instead of being undone by hand.
- **Sessions and resume** — Transcripts are kept per folder. Resume the folder's last session or pick a specific one — the CLI has --continue and --resume, and the desktop app keeps a session list.
- **Plans, scratchpads and sub-agents** — A todo list keeps the plan visible while it works, a thinking mode gives the model a turn to reason without acting, and a task tool can hand a self-contained job to a sub-agent with its own context and budget.

### Permissions and safety

- **Five session permission modes** — Manual, auto-edit, plan, full-auto and bypass — plus separate auto-approve buckets for reads, writes and command execution, so you decide how much the agent may do without asking.
- **Rules files** — A project or user config can allow, deny or force prompts per tool and glob — tool(glob) entries, with deny always outranking bypass mode.
- **High-risk actions always ask** — Deleting recursively, sudo, piping curl into a shell, git push, npm publish, production deploys and migrations against a real database prompt even in permissive modes.

### Skills

Skills are written playbooks the agent loads when a task matches — a better approach on file, instead of improvised each time.

- **A built-in library** — 28 playbooks ship with the app, covering code review, testing, build-error debugging, authentication, database design, API design, security review, performance audits, deploy checklists, git workflow, landing pages, dashboards, interface polish, motion design, PDFs, spreadsheets, presentations, research reports and more.
- **Project skills** — Drop a folder in .htvag/skills/<name>/SKILL.md and the whole team gets it. A project skill overrides a built-in of the same name, so a repo can sharpen how its own work is done.
- **You control which are on** — Enable, disable, read and add skills in the app's skills panel, or from the CLI. A disabled skill is filtered out before the prompt is built — it costs zero tokens and cannot be loaded.

## The always-on assistant

The half that keeps working when you are not watching: local memory, scheduled runs, and replies to the messages that pile up.

### What it can do

- **Local memory** — The assistant builds a profile and a set of durable facts about how you like your work done, extracted after chats and stored on your machine — searchable, editable, forgettable, and switchable off.
- **Schedules** — Give a prompt a time or frequency and it runs headlessly in the folder you choose: catch-up after the PC slept, one run at a time, quiet hours it will not cross, a run-now button and a notice when a slot was missed.
- **No token cap on scheduled runs** — A due schedule simply runs. Since v0.9.33 there is no per-day token budget that pauses the scheduler — the limits are quiet hours, concurrency and the workspace being busy.
- **Notification auto-reply** — On Windows the assistant watches notifications and classifies each one with deterministic guard rules first — no model call for the obvious ones. A reply can be drafted for your approval or sent automatically into the app, with per-app and per-person rules.
- **Sender policies and rate limits** — Who may be answered (anyone, only people you list, or only unknown numbers), who is never answered, per-day and per-hour caps, and per-chat cooldowns. OTP, banking and verification messages are never answered, and the built-in refusal patterns cannot be removed.
- **Approval inbox and audit** — Draft replies wait in an approval inbox you can act on. Scheduled runs, replies and PC actions all write to an audit log you can read — and clear — from the app.

## PC control

The agent can drive your own machine — open apps, click, type, scroll — with the same verify-what-you-did loop it applies to code. Off by default, and every action is logged.

### How it drives the desktop

- **Desktop tools** — Launch and quit apps by name, open URLs, list/focus/minimize/maximize/close windows, take screenshots, click, type, press keys, scroll, read and write the clipboard, wait for the UI to settle, and read the action audit.
- **Clicks anchored to what it saw** — The agent picks coordinates off a screenshot, and the tools map that pick onto the real screen — accounting for the downscaled capture and for where the capture started, so multi-monitor layouts land where the screenshot said. The cursor glides to the target so you can see where it is about to click.
- **Front-window discipline** — Launch-and-focus brings a new window to the foreground and confirms it before anything is clicked, and a refused focus is reported instead of silently clicking whatever happened to be on top.
- **PC workflows** — Pick the jobs you actually want — WhatsApp reply, WhatsApp send, a browser task, file work in Explorer, playing something on YouTube — and only those playbooks enter the prompt. An auto-reply task carries its app's playbook automatically.
- **Live screen mirror** — While PC control runs, a floating picture-in-picture mirror shows what the agent sees. Because it re-screenshots after every action, the mirror behaves like a slow live feed — with the kill switch next to it.

### Safety

- **Kill switch** — A hotkey and a tray action stop PC control immediately, and the stop also halts an auto-reply that was in flight. The live mirror carries the same button.
- **Blocked apps** — A blocklist of app names and window-title patterns the agent will not touch — password managers and banking apps by default, and anything else you add.
- **Secrets are refused** — The typing tool refuses passwords, one-time codes, card numbers and API keys by design — those stay yours to type. It also refuses to type into password and OTP fields.
- **Approvals and audit** — Riskier actions ask first (closing a window and launching an app always do), and every desktop action is written to an append-only audit log with the target window and the result.
- **It sees before it acts** — A run without vision is refused before it can click — either the main model or a configured vision model must be able to look at the screen.
- **Automation yields to you** — If you take the mouse or keyboard while a run is driving, automation backs off — the app says so while it works, and the run gets out of your way.

## Htvag Editor — the AI video editor

A second product in the same family: a prompt-driven video editor that reads your footage and your music before it cuts anything. It runs as a desktop app and in the browser.

### How it edits

- **It looks at the footage first** — It detects scenes and silence and samples frames from each clip, so it knows the subject, the shot size and the strongest moment before anything is placed — your best shot can be first instead of your first file.
- **It reads the music** — A track is analysed for its sections (intro, verse, hook, outro) and its tempo and downbeats, so the edit starts at the main part and cuts land on the beat.
- **A real, editable timeline** — Clips become a timeline document — in and out points, transitions, colour grades and cinematic looks, captions, and music on its own track with ducking under speech. You can play it, undo and redo it, and keep editing by asking in plain language.
- **It checks its own render** — Before the final export it renders a preview and inspects frames from it, fixing what looks wrong instead of assuming the output matches the plan — the same completion discipline as the coding agent.
- **Captions and voice** — Speech is transcribed for captions, and voice-over or voice-note recording is built into the editor.
- **Music you can publish** — Its fetch-music tool finds royalty-free tracks from the Internet Archive's netlabels collection and attaches them to the project.
- **Export** — Render the finished cut and download it — the desktop app and the browser editor share the same project format.

## Everywhere it runs

One account and one agent across surfaces — the desktop app is the full experience; the others cover the moments when a desktop app is not what you need.

### Surfaces

- **Desktop app — Windows and Linux** — The complete experience: the agent, the assistant, PC control, the editor, lessons and the live UI. Installers are published for Windows 10/11 (.exe) and Linux (AppImage and .deb). macOS is not shipped yet.
- **Terminal CLI** — npm install -g htvag-agent gives you the same agent, account and daily credits in a terminal — Node 20+, on macOS, Linux or WSL/PowerShell. Images, sessions, skills, MCP servers, commands and hooks all work there too.
- **Browser chat** — A signed-in chat that needs no install, with voice input where the browser supports it.
- **Browser build** — Describe an app and build it in the browser: a real project running in a WebContainer with a live preview, a code editor pane, and a gallery of design themes to start from.
- **Android companion** — A chat app for your account that can be asked from any app — select text anywhere, pick Htvag Agent, and the answer opens over what you were reading. History lives in on-device SQLite with full-text search that works offline, with personas, saved answers and voice input. It is built separately from the desktop release pipeline.

## How it runs: credits, your key, or your own machine

Three ways to power the same agent. You can switch between them at any time, in the app or from the CLI.

### Engines

- **Included daily credits** — Every signed-in account gets a daily credit allowance that resets at 00:00 UTC — nothing to configure and no API key to find. One credit is roughly 10,000 tokens of genuinely new work; repeated context is served from cache and does not draw it down.
- **Ads top up the free plan** — On the free plan, ad slots in the app pay back a share of what they actually earn, up to 15 extra credits a day on top of the included 5.
- **Your own API key** — If you already pay a model provider, use that key directly: requests go straight to them, your credits are untouched, and keys are stored encrypted in the OS keychain on desktop.
- **Local models with Ollama** — Point the agent at a model running on your own machine and it works offline with no account and no credits at all. Local sessions run a leaner prompt and a smaller tool set sized to the model's context window, and the agent asks for a larger context than Ollama's 4,096-token default so it does not silently truncate.
- **Plans** — The free plan is the complete agent — file edits, shell, tests — with a smaller daily allowance and ads. Paid plans raise the daily credits and the session length. Prices are on the pricing page, in rupees, with UPI and Razorpay checkout.

## Extending and automating it

Three file-based extension points, each committable so a repository carries it for everyone working in it — plus the assistant for work that should happen on a schedule.

### Make it yours

- **MCP servers** — Connect Model Context Protocol servers — an issue tracker, an error monitor, a database, a design tool — and their tools appear in the loop like built-ins: mcp__<server>__<tool>. The config format is the same one Claude Code uses, so server setups copy across unchanged, and a server that fails to start is reported and skipped rather than taking the session down.
- **Custom commands** — A prompt you keep retyping becomes a slash command: a markdown file in the project or your user folder, with $ARGUMENTS and $1… substituted, run by name when you ask for it.
- **Hooks** — Shell commands on tool use and on session stop — format on write, lint before a commit, block a command outright. A failing pre-tool hook blocks the tool, and a failing stop hook pushes the agent back to work.
- **Permission rules** — Project-level allow/deny/ask rules matched per tool and glob, with deny outranking every permissive mode — the difference between 'allowed to use the shell' and 'allowed to use this one command'.
- **Skills and workflows** — Project skills and PC workflows extend the same way: written playbooks the agent loads when the task matches, on your machine or in the repo.

## Privacy and security

The design assumption is that your code and your machine belong to you — the agent borrows them, it does not upload them.

### What stays local

- **Your code never leaves the machine** — File reads, edits and command execution happen locally. Only the instruction and the specific context needed to answer it are sent for processing, and nothing sent is stored.
- **Workspace confinement** — The agent cannot read or write outside the folder you opened for the session — every path, symlinks included, is resolved and checked against the workspace root.
- **Assistant memory and audit stay on disk** — Memory, schedules, the reply inbox and the PC-control audit log are local files in your user profile. Nothing is synced.
- **No private addresses** — The fetch tool refuses private and loopback addresses, so a prompt cannot be turned into a request against your own network.

### Account and keys

- **Browser sign-in with PKCE** — The desktop app is a public OAuth client: it opens the browser, you approve, and the app receives a one-time code it exchanges itself. Codes are single-use and refresh tokens rotate on every exchange.
- **Encrypted provider keys** — Keys you add are encrypted with the OS keychain on desktop and stored with owner-only permissions in the CLI. Passwords on the website are bcrypt-hashed, and sessions are httpOnly cookies.
- **A sandboxed UI** — The desktop renderer runs with context isolation, no Node integration and a content-security policy that forbids remote code; its only capability is the typed bridge the app defines.

## Where to go next

- Download: https://agent.htvag.online/download
- Pricing: https://agent.htvag.online/pricing
- Release notes: https://agent.htvag.online/whats-new
- Documentation: https://agent.htvag.online/docs
- Full LLM reference (pricing and comparisons): https://agent.htvag.online/llms-full.txt
- Short LLM index: https://agent.htvag.online/llms.txt