Everything Htvag Agent does
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.
- 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
Take the whole page with you
Copy every feature as clean markdown — ready to paste into any model — or point an agent at /features.md so it can read the whole reference itself.
Latest release: v0.9.35 — Long runs are no longer cut off by a clock
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.
Start with the free plan
The free plan is the complete agent — file edits, shell, tests and PC control — with a daily credit allowance. No card required.