UtterIDE Agent

Review-first coding for real projects and real databases, inside VS Code.

UtterIDE is a proprietary beta that uses your own model-provider API key. It keeps project state locally, presents consequential actions for review, and lets you work with code and explicitly selected PostgreSQL, PostGIS, and MySQL connections.

What's New in v0.2.0?

Multi-database profiles

UtterIDE now supports PostgreSQL/PostGIS and MySQL through engine-specific adapters. Database profiles are stored globally so they remain available when you change workspace, while every project independently selects which profiles the agent may use. Multiple Development, Staging, and Production profiles can be active in one project.

Provider keys and database connection strings remain in VS Code SecretStorage. The webview and model receive connection display metadata, not saved usernames, passwords, or connection strings.

Bounded schema intelligence

Schema snapshots support PostgreSQL/PostGIS and MySQL, exclude engine system schemas, and retain strict limits on objects, columns, relationships, and serialized size. SQL results remain bounded separately for database transfer, webview rendering, and model context.

Project and database graphs

The Project Graph now presents a bounded overview of the project name, top-level folders, key files, architecture context, and databases enabled for that project. Database profiles remain compact in the master graph; double-clicking one opens its detailed schema, object, and relationship graph. Files and folders support safe open, reveal, and path-copy actions.

Honest engine-specific safety

Every database execution remains review-gated. Destructive actions keep the additional final confirmation. PostgreSQL and MySQL transaction behavior is reported honestly; UtterIDE does not promise automatic database undo or transactional rollback for MySQL DDL that implicitly commits.

Stabilization in v0.1.1

v0.1.1 adds a privacy-safe webview recovery boundary: unexpected interface errors show a local recovery card, discard raw browser error details, and can reload UtterIDE without automatically retrying pending work. Diagnostics report only UI state: ready or UI state: runtime_error.

The interface also receives subtle VS Code-native polish: consistent button states, visible keyboard focus, reduced-motion and high-contrast support, plus clearer Dual AI labels and request-count controls. The existing layout and review-first workflow remain unchanged.

Current beta scope

• Providers: DeepSeek, Anthropic, Gemini, and OpenAI. Provider access, model availability, pricing, and regional limits are controlled by each provider.
• Databases: PostgreSQL, PostGIS, and MySQL. Profiles are available across projects; each project selects which profiles the agent may use. Multiple Development, Staging, and Production profiles can be active together.
• Credentials: Provider keys and database credentials are stored in VS Code SecretStorage. Database passwords are requested in protected VS Code dialogs and are not exposed to the webview or model.
• Billing: UtterIDE includes no model credits. Provider token usage is shown when reported; monetary cost is an estimate only when verified pricing for the exact model is configured.

What's New in v0.1.0?

Safer terminal review

Commands that run project or script code are now labelled EXECUTES PROJECT CODE, including chained commands and common Python, Node, package-script, and test runners. Where possible, the approval card offers a direct review action for the script or package.json. This is conservative risk presentation, not a sandbox; terminal execution still requires approval.

Faster bounded database context

The Databases and Graph views share a five-minute, read-only Schema Snapshot. It excludes PostgreSQL system schemas, never reads table rows or column-default literals, and enforces limits on schemas, objects, columns, relationships, and serialized size. Schema-changing SQL invalidates the cache. Refreshing or loading an uncached snapshot requires database-read approval.

Dedicated Graph and SQL results

Graph now has its own top-level tab for project and selected-database architecture. Database graphs show tables, views, key columns, and foreign-key relationships from the bounded snapshot. SQL rows render in a dedicated, scrollable, text-only table capped at 25 visible rows and 20 visible columns, with copy-cell, copy-row, and copy-visible-result actions.

File navigation and private run summaries

Reviewable file surfaces now support safe Open, Reveal in Explorer, and path copy actions while blocking paths and symlinks outside the workspace. Each run ends with a collapsed summary containing only status, duration, action counts, patch outcomes, failures, and provider usage. It excludes prompts, code, paths, SQL, rows, and credentials.

v0.0.14 foundation

Local provider status

Settings now shows whether each provider is configured, ready, untested, or needs attention. Status is derived from local key presence and normalized UtterIDE run outcomes. Refreshing the card does not send a model prompt or consume provider tokens.

Reviewable patch revert

After UtterIDE applies a patch, Review revert opens the reverse change for review and requires a new approval. Revert is available only for patches applied by UtterIDE during the current extension session. A hash check blocks automatic revert if the file changed after the patch or during review. Terminal, Git, and database actions are not presented as automatically reversible.

Clearer database preview

SQL approval cards now adapt locally derived detail to the risk: reads emphasize operation, target, timeout, and row limit; writes emphasize target, WHERE status, and transaction behavior; destructive actions retain the full safety view. This preview does not execute an additional SQL query. Existing SQL approval and typed-alias protections remain in place.

v0.0.13 foundation

Guided first run

The Dashboard now shows a small three-step guide for connecting a provider, opening a workspace, and completing the first request. Database setup remains optional.

Safe recovery

Provider failures now offer Retry, Fresh Context, Settings, diagnostics, and bug-report actions as appropriate. Retry resubmits the request but never bypasses patch, terminal, Git, or database approvals.

Privacy-safe diagnostics

Diagnostic reports contain version, platform, provider/model identifiers, autonomy mode, run state, error category, and the last safe activity label. Prompts, code, SQL, rows, local paths, credentials, and raw provider errors are excluded.

Safer direct answers and database targeting

Exact Reply only: ... requests cannot execute tools, even if the provider tries to inspect project context. Database tools now resolve a selected connection by either its internal ID or its unique alias, while ambiguous aliases are blocked. DeepSeek V4 usage includes a labelled USD estimate using documented pricing and a conservative cache-miss assumption.

Core capabilities

🛡️ Review-First Architecture

UtterIDE generates VS Code Diff Patches. You review exactly what the AI wants to change before it is applied.

🔒 Local-First Privacy

UtterIDE saves chats, architecture graphs, and settings locally in your project's .utteride folder. Code and prompts are sent only to the model provider you choose; UtterIDE does not operate a server that receives them.

When VS Code telemetry is enabled, UtterIDE sends limited pseudonymous product events to PostHog's EU endpoint: app opened, first agent run started (including provider ID), database connected, database schema scanned, and allowlisted onboarding/recovery actions such as guide shown/completed/dismissed, Retry, Fresh Context, and diagnostics copied. It never includes code, prompts, file names or paths, SQL queries, database data, connection strings, credentials, API keys, or arbitrary error messages. Disable VS Code Telemetry at any time to opt out.

Try UtterIDE Beta Today

Important beta limitations

• Microsoft SQL Server, SQLite, GeoPackage, and geodatabase adapters are not included in v0.2.0.
• UtterIDE does not create or administer database servers or databases. Database-object changes inside a selected PostgreSQL/PostGIS or MySQL database can be proposed as reviewed SQL.
• Database actions do not have automatic undo. Use backups, transactions, disposable development data, and least-privilege roles.
• SQL previews retain at most 100 rows or 100 KB. The UI displays at most 25 rows and 20 columns, while the model receives at most 10 rows or 2 KB. Preview limits protect the UI and model context; expensive joins, sorts, and aggregates can still load the database.
• Terminal risk labels and approvals are review controls, not an operating system sandbox. Approved commands run with your local VS Code user permissions.
• UtterIDE does not automatically research the web, download and execute software, deploy projects, install its own VSIX, or guarantee generated output.
• Dual AI Debate is an experimental Labs feature. One round makes two provider requests: one Alpha response and one Beta response.

Frequently Asked Questions

Is UtterIDE free?

UtterIDE is currently available as a free beta. You bring your own API key and pay the model provider directly for any API usage. Features, pricing, and availability may change in future releases.

Does UtterIDE include AI tokens or API credits?

No. UtterIDE does not sell or bundle model tokens during the beta. Usage and charges belong to the provider account connected with your API key.

Are the displayed token counts and costs exact?

Token counts are provider-reported when the provider supplies them. Monetary cost is a local estimate based on the labelled pricing date and available cache information. If exact pricing or complete provider usage is unavailable, UtterIDE says so instead of inventing a value. The provider dashboard and invoice are authoritative.

Where are my API keys stored?

Provider API keys are stored using Visual Studio Code's SecretStorage. UtterIDE does not intentionally place them in project files, prompts, logs, or telemetry.

Database credentials are also stored in VS Code SecretStorage. Saved usernames, passwords, and connection strings remain in the extension host: the Databases tab receives only display metadata such as alias, environment, host, port, and database name. Credential entry and replacement use protected VS Code dialogs.

Is my code uploaded to UtterIDE?

UtterIDE does not operate a backend that receives or stores your source code. When you use a cloud model, the prompt and selected project context are sent directly to the provider you choose. Review that provider's privacy and retention terms before using confidential code.

What telemetry is collected?

When VS Code telemetry is enabled, UtterIDE sends a small allowlisted set of pseudonymous product events to PostHog's EU endpoint. This includes basic activation, provider-ID-at-first-run, database connection/schema, onboarding progress, Retry/Fresh Context selection, and diagnostics-copied events. It does not include code, prompts, file names or paths, SQL, database content, connection strings, credentials, API keys, or arbitrary error messages. Disable VS Code Telemetry to opt out.

Can UtterIDE change files without approval?

No. Code patches require review before they are applied. Terminal commands, Git commit/push, and every database execution also require explicit approval in every autonomy mode. Read-only workspace searches may run automatically outside Safe mode.

Applying a patch does not automatically create a Git commit. Commit and push are separate reviewed actions.

For a patch applied by UtterIDE in the current extension session, Review revert can propose the inverse change. Revert requires another review and is blocked when the file no longer matches the exact post-patch content. It is a convenience for recent UtterIDE patches, not a replacement for Git.

Does UtterIDE connect to my database automatically?

No. A database must be configured and selected by you. execute_sql supports reviewed reads, row changes, schema changes, and workspace .sql migrations. UtterIDE classifies each request as read, write, schema, or destructive and shows the connection and exact masked SQL before approval. Production and destructive SQL require stronger confirmation. Reads are constrained by the selected engine adapter; supported writes use managed transactions where the engine permits them. MySQL DDL may implicitly commit and is never presented as automatically reversible. Statement timeout, result limits, and local PII masking still apply. Prefer disposable development data, backups, and a dedicated least-privilege database role.

Saved database credentials are not sent to the model. Query text and locally masked query results may be sent to the selected cloud model as part of the agent conversation.

Which databases are supported?

v0.2.0 supports PostgreSQL, PostGIS, and MySQL. Additional database engines are not included in this beta.

Can one project use multiple databases?

Yes. Database profiles remain available across workspaces, and each project chooses which profiles are active for its agent. Profiles that are not selected remain saved but cannot be used by the agent in that project.

Why does UtterIDE sometimes warn about a large context?

UtterIDE bounds recent chat, active-file, project-memory, and mentioned-file context. Before an unusually large provider request, it shows an approximate token warning and lets you continue with bounded context, use fresh chat context, or cancel.

Which model providers are supported?

v0.2.0 includes DeepSeek, Anthropic, Gemini, and OpenAI integrations. The available provider list is shown inside UtterIDE. Provider availability, model names, prices, context limits, and regional access are controlled by each provider and may change.

What should I do if a run gets stuck?

Press Stop to cancel the active run and pending approval. For provider failures, use Retry request, Start fresh context, or the relevant Settings action shown in the recovery card. Retry does not automatically repeat a previously approved patch, terminal command, Git action, or SQL execution.

What is included in copied diagnostics?

The report includes UtterIDE/VS Code versions, operating system, provider and model identifiers, autonomy mode, run state, error category, and last safe activity label. It intentionally excludes prompts, code, SQL, database rows, local paths, credentials, and raw provider errors.

Is this open-source software?

No. The UtterIDE beta is proprietary software. Installing it does not grant permission to copy, modify, redistribute, republish, reverse engineer, or sell the extension except where applicable law expressly permits.

Where can I report a bug?

Report reproducible issues at UtterIDE Website Issues. Do not include API keys, credentials, proprietary source code, database contents, or other sensitive information.

For product information, visit utteride.se.