This guide covers the new client under development, integration, and acceptance testing, including completed features and recent integration changes. Public installer delivery is pending. Feature availability and operating system support are specified in the release notes for each version. Downloads and beta ↗
Content checked · October 11, 2026
02 / FEATURES
Feature overview
Grandet manages app integrations, account selection, model tests, and cost records for workflows using multiple AI apps or API accounts.
Features and uses
Requirement
Feature
Use
App configuration
Stores accounts centrally and provides the corresponding integration for each app.
Manage API connections across apps.
Account selection
Selects connected and available accounts that meet the conditions for the requested model, with free credit priority.
Select request accounts by price and credit conditions.
Model testing
Picky saves questions, answers, and scores and compares compatible test records.
Review test results and assess account replacements.
Account replacement
Supports pinned accounts and the Replace and Undo actions when an eligible alternative exists.
Specify the account for subsequent requests.
Cost records
Filters records by date, app, account, and model and displays request attempts and cost status.
Verify cost sources and unconfirmed amounts.
Workflow
Model selection
Model selection and task operations remain in the original app after connection to Grandet.
Connection selection
Connection selection uses model, authorization, and pricing conditions. Pinned accounts are supported.
Picky tests
Supported apps can start tests and display questions, answers, and results for the current connection. Compatible records support comparisons across accounts using the same model name.
Cost records
Records can be filtered by app or model and distinguish known costs, request attempts, and unconfirmed amounts.
Use cases
MULTIPLE AI APPS
Central management
Developers, frequent AI users, and agent users can connect existing tools to their own API accounts.
MULTIPLE API ACCOUNTS
Cost and performance
Pricing conditions, test results, and usage records provide evidence for account selection.
Demonstration sequence
The demonstration covers app integration, account selection for the same model, Picky questions, answers, and provider comparisons, and cost records filtered by app.
Grandet supports coding assistants, IDEs, agents, and chat apps, with central management of API accounts and connections.
App coverage
The table lists representative apps. Integration methods and available features depend on the app, host version, operating system, and configuration.
Use case
Example apps
Integration scope
Coding and CLI
Codex, Claude Code, OpenCode, Cline, Gemini CLI
Uses the corresponding inference API. Compatible hosts can also call MCP tools.
Agent workflows
Hermes, OpenClaw
Uses supported API protocols. MCP capabilities depend on the host configuration.
IDEs and extensions
Kilo Code, Continue, WorkBuddy, Trae IDE
Uses supported custom APIs or extension configurations. Some versions have additional requirements.
Desktop chat
Chatbox and other apps with custom API support
Uses imported or manually entered connection details from Grandet.
MCP tools
Cursor, Windsurf, and other MCP clients
Compatible hosts can call Grandet tools after configuration. Scope is limited to MCP tools and excludes native model requests and subscription management.
Other compatible tools
Clients supporting Chat, Responses, Messages, the native Gemini API, or MCP
Requires a supported protocol and the corresponding configuration. Generic CLI tools also require a valid protocol or MCP binding.
Integration steps
Add API accounts
Requires an authorized API key and service address. Recognized providers display setup information. Unknown providers require an address and other connection details.
Connect an app
Grandet suggests integrations based on installed or running apps. Setup methods include automatic configuration, launch commands, imports, and visual guides, depending on the app.
Model settings
Supported apps can retain existing model settings. Missing model information requires selection. Task operations remain in the original app.
Disconnect an app
Individual apps can be disconnected with restoration of the configuration changed by Grandet. Other app connections remain unchanged.
Picky integrations
Supported apps can start tests after connecting to the new Grandet backend. Claude Code uses a dedicated plugin, Codex uses a Picky skill, and compatible chat interfaces accept the exact command /picky or Grandet Picky. MCP hosts can call the Picky tool.
Tests run in the Grandet backend. Questions, answers, and results return to the initiating app. Progress queries, status queries, and stopping tests are supported.
Integration scope
Inference integrations route model requests through Grandet. MCP integrations provide tool calls. Picky execution against native subscription models remains pending. Plugins require a matching version of the new Grandet backend.
Picky runs capability tests on connected API services that support active testing. It saves questions, model answers, and scores for performance review and account comparison.
Test workflow
01Start a testIn Grandet or a connected app
→
02Review resultsQuestions, answers, scores, and history
→
03Account selectionRetain or replace an account
Test scope
The current test set measures response performance with scorable tasks in six categories: code reasoning, multi-step math, logic and planning, instruction constraints, reading and evidence synthesis, and applying basic knowledge.
Code reasoningMulti-step mathLogic and planningInstruction constraintsReading and evidenceKnowledge application
Individual results contain the question, model answer, and score. Reports include known usage and run status, with history queries and copying supported.
Model comparisons
Provider comparisons use compatible test records to compare accounts with the same model name under a shared testing method. Results are displayed for each question. Substantially weaker performance can trigger a “Suspected downgrade” notice.
Compatibility depends on the question bank, scoring rules, and task types. Exact questions may differ between providers. Model names are supplied by providers. Comparisons require assessment alongside answers and test conditions.
Replace and Undo
The current connection can be retained. “Replace” is available when another available account serves the same model and performs better on compatible tests. Replacement applies from the next request and supports “Undo”.
Account replacement is selected by the user. Picky provides performance notices and scores; model identity requires independent verification.
Test steps
Confirm connection and model
Tests are available from “Test intelligence” in Grandet or the Picky entry point in a connected app.
Confirm the request budget
Tests create additional API usage. Missing authorization requires confirmation of the test scope. Available cost estimates appear with the budget.
Review results
Tests run in the background, one question at a time, and support stop requests. Requests already sent may still incur charges.
Records and retesting
History queries, report copying, and retesting under compatible conditions are supported.
Test limitations
Picky is an experimental model capability testing tool. Scoring and notification rules remain under calibration. Results indicate performance changes within the test scope. Model identity, provider performance, and real-task capability require independent evidence and task-specific evaluation. Test budgets are client-side constraints. Final charges follow the provider's records.
Grandet Personal is a local client that connects AI apps to user-owned API accounts, selects request accounts according to configuration, and records usage and costs.
Connection selection
Grandet filters connected accounts by the exact model requested in the original app and other applicable conditions. Automatic mode considers availability, prices, and credit conditions. Free credit priority and pinned accounts are supported.
Public catalog prices support research and comparison. Request execution requires an available account, authorization, and an eligible connection.
App settingsModel selectionExisting app model settings
→
Local managementConnection selectionAccounts, authorization, prices, and budgets
→
Request executionAuthorized providerUser-owned API account
Accounts and budgets
Accounts and models
Displays connection readiness, model information, and missing requirements. Unknown providers require an address. Automatic API key recognition depends on provider support.
Bulk checks
Checks connection readiness across multiple accounts. Model inference is evaluated in separate tests. Picky tests answer quality separately.
Budgets and credits
Supports budget settings and displays known costs and reserved amounts. Free credits remain subject to their eligibility rules, expiration dates, and usage limits.
Connection selection
Automatic selection and pinned accounts follow the configuration. Picky provides test results. The user chooses whether to switch to an available account for the same model with better results on compatible tests.
Cost records
Cost records support filters by date, app, account, and model, batch history loading, and individual details. Details include request attempts, cost evidence, and unconfirmed status for reviewing failed or interrupted requests.
Currencies are recorded separately. Historical costs retain their original billing basis. Amounts with insufficient evidence remain unknown and can be checked against provider bills.
Controls and storage
Supported actions include pinning accounts, stopping tests, undoing reversible account replacements, and disconnecting individual apps. Credentials are stored with protection on the local device. Inference requests are sent to the provider selected and authorized by the user.
Grandet centrally manages app integrations and API account connections.
Price comparisons require the model, billing unit, plan conditions, source, and collection date.
Price comparison
Model and version
Model names and versions follow the source listing. Service equivalence requires review of model versions and source descriptions.
Billing units
Billing methods include currency prices, provider credits, per-request charges, and time-based charges. Provider credits require the applicable conversion terms.
Input and output prices
Long-document analysis typically has high input usage; long-form generation has high output usage. Input and output prices require comparison within the same plan. Cache charges follow separate rules.
Limits and conditions
Context length, service region, processing mode, and account group may affect prices. Tiered prices depend on the conditions listed in the pricing details.
Source and date
Current terms and account eligibility follow the source page. Page update dates may differ from price collection dates.
Cost calculator
This calculator uses hypothetical prices in US dollars to estimate base charges from input and output usage.
Actual cost
Actual cost depends on top-up conversion rates, membership conditions, promotional credits, additional charges, and usage. Price rankings compare listed prices. Service quality and model identity require separate verification.
Cost estimates require the intended use and full billing terms, with reconciliation against the provider’s actual bill.
Grandet lists free APIs, trial credits, and cloud credits. Eligibility and usage rules follow the provider’s official terms.
Credit types
New-user trials
Usually require first registration, activation, or verification, with possible one-time limits and expiry dates.
Recurring free usage
Resets daily, monthly, or on another schedule, often with limits on speed, models, or permitted uses.
Application programs
For students, research, or startups. Eligibility and approval are required; the provider determines the awarded credits.
Cloud credits
Offset specified cloud service charges. Model usage eligibility follows the credit terms.
Application conditions
Eligibility
Eligibility depends on region, account type, new- or existing-user restrictions, and identity verification or application requirements.
Coverage
Restrictions may include evaluation-only use or coverage limited to specified models, regions, or services.
Validity
The promotion end date, validity period after activation, and account expiry date may differ.
Credit exhaustion
After credits are exhausted, service may pause, downgrade, or become paid, depending on service terms, payment methods, and automatic renewal settings.
Account confirmation
The account record determines the credited amount, terms, and available coverage.
Eligibility verification
Records include a verification date. Application eligibility follows the current official terms.
Installation status, app support, test scope, and billing rules for the new client.
Availability and setup
Release status
The website’s price and free credits directories are available. The new client remains in development and acceptance testing. Some enhancements are in integrated builds, and public installer delivery is pending. Available versions and features are listed on the download page.
App connections
Supported apps connect to Grandet through custom API settings, configuration, plugins, or MCP. App replacement is unnecessary. Connection methods are listed under App connections.
Support scope
Configuration and support vary by app. Some connections support model requests; others provide MCP tools only. Cursor and Windsurf refer here to MCP tool connections. Native model and subscription requests follow each app’s configuration. Real-device coverage follows the acceptance records for each app and operating system version.
API accounts
Public directories are accessible directly. The client uses API accounts the user is authorized to access. Each provider determines account availability, balances, and terms.
Picky tests
Model identity
Picky records responses, scores, and differences for review. Neither test results nor model names independently establish the model’s actual identity.
“Suspected downgrade”
This label indicates that account performance triggered an experimental difference rule among currently comparable records. The finding remains subject to verification. Questions, answers, test conditions, and retest results support further review.
Comparison conditions
Tests are organized by version and question type. Cross-provider comparisons require compatible methods, but individual questions may differ. Historical comparisons for the same connection also require compatible records.
Test costs and triggers
Active tests are user-initiated, use authorized connections and the applicable budget, and generate additional API usage. Paid retries are user-initiated. The client budget controls test usage; final charges follow the provider’s bill.
Native subscriptions
Current in-app entry points use API backends connected to Grandet. The Picky plugin uses the same API backend. Native subscription test support remains pending.
Costs and connections
Model and account selection
Account selection filters available accounts by the exact requested model name and applicable conditions. Price comparison covers connected accounts. Model identity requires separate verification. The client supports pinning an account; Picky tests model performance separately.
Savings
Savings depend on accounts, credits, usage, pricing conditions, and task requirements. The savings percentage follows actual usage and billing.
Data processing
Accounts and management state are handled locally. Inference content is sent to the provider selected and authorized by the user. Data processing is described in the Grandet privacy notice and the provider’s policies.
09 / COMMUNITY
Community feedback
Feedback covers app connections, account selection, Picky tests, cost records, and corrections to prices or terms. Issue reports should include the use case and verifiable results.
Suggested correction details include the Grandet page, original provider link, discovery date, and the price, unit, eligibility condition, or expiry date requiring correction.
Issue reports
Suggested report details include the feature or version, reproduction steps, expected result, and actual result. Logs and screenshots must exclude keys, tokens, private conversations, and sensitive account information.
Feedback template
Grandet version and operating system:
App name, version, and connection method:
Task:
Steps to reproduce:
Expected result:
Actual result:
Picky report or related records (sensitive information removed):
Related page or public source:
Time of occurrence and time zone:
Feature suggestions
Suggested details include the use case, current workaround, intended users, and expected result.
Adoption, delivery, and release status follow product announcements on the official website.
10 / GLOSSARY
Glossary
Terms used in pricing, billing, and product documentation.
Prices and billing
Token
A unit of content processed by a model, whose conversion to characters or words depends on model tokenization.
Input and output
Input is content sent to a model; output is content generated by the model. Their unit prices may differ.
Cache pricing
Prices applicable under specified caching conditions, determined by provider rules and request characteristics.
Provider credits
A provider-defined balance or points unit, converted to currency using the applicable top-up and conversion terms.
Estimated cost
An amount calculated from unit prices, usage assumptions, and applicable conditions. The actual bill depends on final usage and complete billing rules.
Product terms
Public quote
A source’s published price, date, scope, and terms.
Collection time
The time a price or set of terms was read, distinct from the page’s republication date.
API connection
The account, credentials, and settings required to access a provider’s API.
Routing
Selecting a provider connection for a request based on the model, capabilities, account authorization, budget, and other conditions.
Private beta
A stage of limited feature testing. Public installation availability, official support, and delivery dates follow release notes.
Picky
Grandet’s experimental model capability tests, using questions, answers, scores, and comparisons of compatible records to assess API connection performance.
MCP
A protocol for AI apps to call external tools. MCP access supports tool calls. Model request forwarding requires separate configuration.
Connection selection
Selecting a connection from authorized, available accounts using the exact requested model name and other applicable conditions.