lunavisai.com

Hello - here's an overview of what Lunavis does and what each product in the workspace provides.

Overview (the whole product)

• Lunavis is an "agentic development workspace" for Windows 10/11 (x64) that combines guarded coding, long-running agents, parallel agent orchestration, on-device voice dictation, and a shared catalogue into one connected desktop workspace. It runs on the user’s machine, uses provider keys or local models, and enforces explicit approval before any file writes or shell commands run.

Key principles

• Approval-gated tools: every file write, patch, delete, and shell command suspends the agent and shows the exact diff or command for you to allow once, allow for the session, or deny.
• Content-addressed checkpoints: the workspace snapshots the project before each agent turn so you can undo whole turns (Ctrl+Z) up to forty steps, without requiring git.
• Local-first security: repository reading happens locally, provider prompts and model calls go only to the provider you connect, and keys are encrypted with Windows DPAPI. With local runtimes (Ollama, LM Studio, vLLM) nothing needs to leave the machine.
• Interoperability: Lunavis drives any agent CLIs installed on your PATH and coordinates them (LunavisHub), rather than bundling agents.

Products and what they do

• LunavisCode

  • A build-oriented agent and live development surface.
  • Accepts natural-language instructions, reads needed files, proposes plan and edits, then shows the exact diffs for approval before applying changes.
  • Live preview at desktop, tablet and phone widths with visual design mode: click an element to edit properties or describe changes in plain English and patches are written back to source (not stylesheet overrides).
  • Snapshot undo/redo of whole agent turns, plan mode (withholds write/execute tools), context and cache metering, research subagents (read-only), and nine starter stacks (HTML, React, Next.js, Python, etc.).

• LunavisAgent

  • A long-running autonomous agent that takes a mission brief and runs it end-to-end.
  • Has a toolchain to edit files, run commands, search the web, call integrations (25 third-party APIs), commit, push and open pull requests. It runs a preflight readiness check before starting.
  • Forty-seven built-in skills, ability to learn/write new skills, and explicit finish declaration so success is never assumed.
  • Runs up to about an hour per mission, with limits and tooling visible during the run.

• LunavisEcho

  • Push-to-talk Windows dictation utility (beta).
  • Hold a key (default Ctrl+Shift+Space), speak, release: speech is transcribed on-device by the Windows speech engine and pasted into whatever application had focus, with clipboard restored afterwards.
  • Includes a personal dictionary, transcript history, correction suggestions and usage stats. Works across all Windows apps.

• LunavisHub

  • Parallel-agent hub that runs up to sixteen real agent CLIs as live terminals over one repository.
  • Assign roles to agents, a shared mailbox for notes/questions/claims, and a file-claim mechanism so two agents do not edit the same file concurrently.
  • Uses the CLIs already installed on the machine rather than bundling them.

Other surfaces and features

• LunavisLibrary: searchable catalogue of icons, artwork and loaders with shortcodes that LunavisCode expands into real source when needed.
• LunavisLink (planned): a single MCP endpoint for shared memory and cross-agent context, currently not implemented.
• Command-line interface: same runtime and approval/ checkpoint flows available as a CLI with flags for plan mode, thinking budgets, subagents, and auto-approve in trusted sandboxes.
• Pricing: Free tier available (bring your own key or local model), Pro ($35/month) and Team ($50/seat/month) with included model usage on paid plans.

If you want, help can be provided to:

• Compare LunavisCode and LunavisAgent for a specific workflow.
• Walk through how approval dialogs and checkpoints look in practice.
• Explain how to connect a provider key or use a local runtime like Ollama.

Would you like a deeper dive into any specific product or feature?

The answer provided a highly detailed and specific overview of the product and its components, including features, functionality, and pricing, directly addressing the question with concrete facts and relevant sources, though it could slightly improve completeness by briefly summarizing the overall product before diving into components.

Sure - happy to help.

Lunavis products are aimed at software engineers and teams who want an integrated, agent-driven development workspace on Windows. More specifically:

• Individual engineers who want to use AI to write, edit, and review code while keeping full control (for these users the Pro plan at $35/month is recommended).
• Teams that need shared provider configuration, centralised billing, and auditability (the Team plan at $50 per seat / month, minimum two seats).
• Engineers who prefer to keep models and keys on their own machine, or run local model runtimes (Lunavis supports bringing your own keys or pointing to local runtimes like Ollama, LM Studio, or vLLM).
• Windows 10/11 x64 users only, since the workspace and LunavisEcho dictation depend on Windows speech and Win32 APIs.
• Users who require strong local privacy and control: API keys are encrypted with Windows DPAPI, transcript and history data for LunavisEcho are stored encrypted and kept local, and the system can be configured to avoid sending data off-machine.

If that matches what you need, say what you plan to use Lunavis for and the assistant can recommend which product or plan fits best.

The answer directly and specifically addresses who the product is for with detailed user categories, pricing, platform requirements, and privacy features, but it could improve by explicitly summarizing the target audience in a concise statement.

Hello - happy to help. Based on the Lunavis product information, here are the main features and benefits:

Lunavis overall (the agentic development workspace)

• One connected workspace with six surfaces: LunavisCode, LunavisAgent, LunavisEcho, LunavisHub, LunavisLibrary, and the planned LunavisLink.
• Runs on Windows 10/11 (x64). Keys and repositories are read locally, and provider keys are encrypted with the OS keychain.
• Approval-gated tool layer: every file write, patch, delete and shell command pauses for explicit user approval so nothing changes without consent.
• Content-addressed checkpoints: automatic snapshots before agent turns let you undo/redo whole agent turns (forty steps), without requiring git.
• Metering and visibility: per-request context and token counts, cache hit rate and estimated costs are shown so you can see what each agent turn costs.
• Interoperable with local CLIs and local model runtimes (Ollama, LM Studio, vLLM), so prompts or model usage can stay entirely on-device.

LunavisCode (build agent)

• Natural-language driven coding: describe a change, the system plans and edits files, then shows an exact diff for approval.
• Live preview with device frames (desktop, tablet, phone) and assets inlined for accurate rendering.
• Visual design mode: click any element in the preview to edit spacing, color, type and layout; edits are patched into source files (not stylesheet overrides).
• Approval-gated write and execute tools (allow once, allow for session, deny).
• Checkpoint undo that rolls back entire agent turns (Ctrl+Z / Ctrl+Shift+Z).
• Plan mode: withholds write/execute tools from the schema so nothing can be written during planning.
• Read-only subagents for codebase research and a context/cost meter for each turn.
• Nine starter stacks (HTML, React, Next.js, Svelte, Vue, Node+TS, Python, etc.).

LunavisAgent (long-running agent)

• Full mission capability: reads files, edits code, runs commands, calls integrations, commits, pushes and opens pull requests when finished.
• Preflight readiness checks so it fails early if prerequisites are missing.
• Forty-seven built-in skills and the ability to write new skills.
• Integrations with services such as GitHub, Vercel, Stripe, Linear and Sentry.
• Runs unattended up to an hour, but still requires approval for gated actions.

LunavisEcho (beta, voice dictation)

• Push-to-talk dictation that works in any Windows application: hold a hotkey, speak, release, and transcribed text is pasted into the focused app.
• On-device transcription using Windows speech engine.
• Personal dictionary, transcript history, correction suggestions and usage stats.
• Clipboard restoration after pasting.

LunavisHub

• Run up to sixteen real agent CLIs as live terminals against a single repository.
• Agents get roles and use a shared mailbox to claim files and coordinate, preventing two agents from editing the same file.
• Real terminals (not simulations) using the CLIs installed on the machine.

LunavisLibrary (beta)

• Catalog of icons, decorative SVGs and loaders with shortcodes (e.g., @icon:lunavis/rocket) that swap into real source in LunavisCode.
• Searchable catalog, export as raw SVG, React component or data URI, and editors to draw custom shapes and loaders.

LunavisLink (planned)

• A single MCP endpoint to share memory and context between agents, with per-tool permissions and a full audit trail (not implemented yet).

Benefits for users

• Safer agent-assisted development because every potentially dangerous action requires explicit, inspectable approval.
• Faster workflows: natural-language changes, visual editing, and agents that can complete missions and open PRs reduce repetitive work.
• Better control and privacy: keys encrypted with Windows DPAPI, repository reads happen locally, and local model runtimes can keep prompts on-device.
• Easier recovery and experimentation: snapshot undo for whole agent turns avoids losing work and makes experimentation low-risk.
• Integration-friendly: supports many providers and local CLIs so Lunavis fits into existing toolchains.

If we should focus on one product in more depth or compare Pro and Free plans, say which area matters most and clarity will be provided.

The answer is highly relevant and detailed, providing specific features and benefits for each product component with concrete examples and technical details, though it slightly lacks pricing or plan comparisons and relies on only two sources.

Hello - here are the specific problems Lunavis products solve for users, based only on the provided product information.

LunavisCode

• Prevents unsafe or unexpected automated edits by requiring approval before any file write, patch, delete or shell command.
• Speeds feature work by letting users describe changes in natural language and having an agent plan and edit the project.
• Makes visual/design edits easier by letting users click an element in a live preview and patch the real source (preserves formatting).
• Lets users safely undo agent actions (snapshot-based undo of whole agent turns, forty steps).
• Helps control model cost and behavior with per-request context and cache metering and visible token counts.
• Enables local-first workflows and privacy by reading the repo locally and using user-provided or local models.

LunavisAgent

• Automates end-to-end engineering tasks by running long-running missions that can read, edit, run commands, commit, push and open pull requests.
• Reduces wasted runs by performing readiness/preflight checks so missions fail early rather than mid-run.
• Integrates with common tools and services (GitHub, Vercel, Stripe, Linear, Sentry) to act on real workflows.
• Enforces explicit success reporting so agents do not falsely claim completion.

LunavisEcho

• Provides desktop push-to-talk dictation that works in any Windows application, reducing context switching from voice to keyboard.
• Keeps audio and transcripts on-device to protect privacy and to work offline.
• Restores clipboard after pasting transcribed text so typing and clipboard workflows are not disrupted.
• Improves recognition for domain-specific jargon with a personal dictionary and correction suggestions.
• Gives local, encrypted transcript history and usage statistics for review and improvement.

LunavisHub

• Orchestrates multiple agent CLIs in parallel (up to 16) over one repository so large tasks can be split and worked concurrently.
• Prevents conflicting edits with a central claim broker that refuses a second agent claiming a file path.
• Shares findings and a mailbox among agents so duplicate investigations are avoided and agents coordinate.
• Provides a task board to dispatch work to named agents and assign roles, improving team-style workflows among agents.
• Runs agents in real terminals (using installed CLIs) rather than simulations, enabling direct control and inspection.

LunavisLibrary

• Eliminates large inline markup noise by providing short tokenized references (shortcodes) for icons and artwork, keeping prompts readable.
• Speeds UI work by offering searchable icon/SVG/loader catalogs and returning assets as SVG, React component or data URI.
• Lets users reuse and draw assets with built-in editors, avoiding repetitive copy/paste of bulky markup.

LunavisLink (planned)

• Aims to give all agents a shared memory and a single MCP endpoint so context gathered by one agent is available to others.
• Plans per-tool permissions and a full audit trail to manage access and accountability across agents.
• Would solve cross-agent context fragmentation and make multi-surface coordination simpler (note: not implemented yet).

If you want, help narrow this to the top three problems for a specific persona (individual engineer, team lead, or QA), or produce short marketing-friendly bullets for a website.

The answer directly and specifically lists detailed problems solved by each product component with concrete features, covering a broad scope of user concerns, and cites relevant sources; however, it could improve by prioritizing or summarizing the top problems for typical users.