# MindsHub by MindsDB > MindsHub gives everyone the freedom to choose among leading AI models and providers—whether they use AI to get work done or build it into products. ## Core pages ### AI access, usage, and spending, under control — MindsHub URL: https://mindshub.ai/ #### What is MindsHub? MindsHub brings AI model access, usage, and spending into one place. Use models through MindsHub Inference in your own apps and agents, or work with them in MindsHub Agents. The MindsHub Console provides shared controls for access, billing, and budgets. #### What problem does MindsHub solve? An AI experiment can keep running long after someone stops thinking about it. As more people, agents, and applications call models, the bill grows. Without a clear view of usage, it is hard to tell which work is useful, what is wasting money, or who owns it. Stopping the spend can create another problem: revoking an API key that several applications share can also take down a service people depend on. Teams need to understand what is running and set appropriate access and spending rules before a surprise bill forces a rushed decision. #### How does MindsHub work? For model requests made through MindsHub Inference, the console brings permissions, model access, usage, and budgets together. It helps teams answer four practical questions: - Who can do what? Create roles with the permissions people need, such as creating API keys or viewing billing, without giving everyone full administrator access. - Which models can they use? Manage access by provider or individual model, with rules for a team or the whole organization. - Where is the money going? Review daily spending by model, team, member, or API key, then inspect token usage and costs in the detailed breakdown. - When should we step in? Set a budget for a team, choose the models and budget period, and track spending against its limit. The Alert only option warns at the limit while keeping requests running. Use this view to investigate waste, review who has access, and decide where to adjust spending. #### How can you use MindsHub? Use MindsHub’s full model catalog through Inference, Cowork, or Code. ##### MindsHub Inference Use MindsHub models in your favorite agents, or build your own apps. Connect a third-party agent or your own application to the API. Access models through OpenAI Chat Completions or Anthropic Messages with one MindsHub API key. [Explore Inference](https://mindshub.ai/unified-inference) ##### MindsHub Agents: Cowork Give tasks to our agent workspace. Research, analyze, and create. [Explore Cowork](https://mindshub.ai/agents?mode=cowork) ##### MindsHub Agents: Code Build features, fix bugs, and review code with our Codex-based coding agent. Cowork and Code are two modes of MindsHub Agents. [Explore Code](https://mindshub.ai/agents?mode=code) #### How do you get started? Create a free account, then choose whether to connect an app or agent through the API or use MindsHub Agents. Compare the plans below and visit pricing for the full terms and model rates. [Create free account](https://auth.mindshub.ai/auth/realms/mindsdb/protocol/openid-connect/registrations?client_id=public-client&response_type=code&scope=openid&redirect_uri=https%3A%2F%2Fconsole.mindshub.ai%2F) ##### Free Always free, for knowledge work with agents. $0 / month. No credit card required. - The MindsHub Air model for non-coding work. Air uses a model selected for everyday knowledge work. The underlying model may change as better options become available. - Use in our agents or yours - Classify, route and score with Jev. Jev is TypeSafe’s decision model: it returns choices, scores and probabilities, not chat replies. Call it through the Decisions API as jev with your MindsHub API key. - Daily limits under fair use. Free covers everyday work with agents, in MindsHub Agents or your own. For bulk automation or high-volume workloads, use pay as you go. [Read the fair-use policy](https://mindshub.ai/fair-use-policy) [Create free account](https://auth.mindshub.ai/auth/realms/mindsdb/protocol/openid-connect/registrations?client_id=public-client&response_type=code&scope=openid&redirect_uri=https%3A%2F%2Fconsole.mindshub.ai%2F) ##### Pay as you go Every model, billed at provider rates. Per use at provider rates. Prepaid balance. No expiration or minimum spend. Everything in Free, plus: - Every model in the catalog - Caching savings passed on to you. When you resend content the provider already has cached, such as a long system prompt, it bills at the model’s lower cached-input rate, where the provider offers one. - No plan limits; pay per use - Auto top-up with a monthly cap - Usage and spend tracking [Top up](https://auth.mindshub.ai/auth/realms/mindsdb/protocol/openid-connect/registrations?client_id=public-client&response_type=code&scope=openid&redirect_uri=https%3A%2F%2Fconsole.mindshub.ai%2F) [See full pricing and model rates](https://mindshub.ai/pricing) #### More information [Models](https://mindshub.ai/models) · [Documentation](https://docs.mindshub.ai/inference/) · [Support](https://mindshub.ai/support) · [Privacy](https://mindshub.ai/privacy-policy) · [Terms](https://mindshub.ai/terms) [Site index](https://mindshub.ai/llms.txt) · [Full site text](https://mindshub.ai/llms-full.txt) ### MindsHub Agents URL: https://mindshub.ai/agents MindsHub Agents is MindsHub’s agent workspace for delegating projects in plain language: research, analysis, content creation, and software development. It runs on Anton, an open-source agent harness; in Code mode, the coding agent is Codex. You can switch the model at any time, and switching does not remove your memory or artifacts. It runs in the browser and as a desktop app, and the MindsHub Air model is free to use in it with no credit card required, within the fair-use policy. See https://mindshub.ai/pricing#free-tier for details. MindsHub Agents uses the same catalog, account, and balance as MindsHub Inference. Q: What is MindsHub Agents? A: MindsHub Agents is an agent workspace for delegating projects in plain language. Connect the data and tools it needs, then review and share the documents, dashboards, apps, or reports it produces. Q: Which agent powers MindsHub Agents? A: MindsHub Agents runs on Anton, an open-source agent harness. In Code mode, the coding agent is Codex. Q: Can I switch the model? A: Yes. You can switch the model at any time, and switching does not remove your memory or artifacts. Q: Do I need to pick a model to start? A: No. MindsHub Agents provides defaults, so you can create an account and start a task without choosing a model or API key first. Q: Can I build apps and write code with MindsHub Agents? A: Yes. MindsHub Agents can make internal tools, calculators, small web apps, landing pages, and scripts. Supported artifacts can be published to a URL for others to use. Q: Why isn't a chat box enough for an AI agent? A: A chat stores a conversation. MindsHub Agents also connects data, organizes work into projects, saves reusable context, and publishes results. Q: How does MindsHub Agents connect to my data? A: Connect databases, warehouses, and SaaS tools through the connectors directory. Secrets stay in a vault and are scoped to the connection; the agent does not receive the raw key. Q: Is there a desktop or mobile app? A: MindsHub Agents runs in the browser at cowork.mindshub.ai and as a desktop app for macOS, Windows and Linux (a .deb for Debian and Ubuntu). Mobile apps are planned. Q: How do I get started? A: Create an account in the browser or desktop app, then describe your first task. The MindsHub Air model is free within the fair-use policy and does not require a card. Q: How does MindsHub Agents relate to MindsHub Inference? A: MindsHub Inference is the API for developers building their own products. MindsHub Agents is a ready-to-use workspace built on the same catalog. One account and balance cover both. ### MindsHub Inference URL: https://mindshub.ai/unified-inference MindsHub Inference is the hosted API at api.mindshub.ai. It supports OpenAI Chat Completions and Anthropic Messages in production. The OpenAI Responses endpoint is still being upgraded, so the docs recommend Chat Completions for production use. OpenAI SDKs use https://api.mindshub.ai/v1 with api_key. Anthropic SDKs use https://api.mindshub.ai without /v1 and auth_token. Every model has a fixed alias that names one exact version, such as gpt-6-astra, and most lines also have a rotating alias, such as gpt or sonnet, that tracks the most recent version of its line; GET /v1/models lists the current catalog for your organization. Billing is pay as you go from one prepaid balance. The free tier includes the MindsHub Air model, alias mindshub_air, and TypeSafe’s Jev decision model, alias jev. Fair use and rate limits apply. Jev returns choices, scores and probabilities through POST /v1/decisions with a MindsHub API key. See https://mindshub.ai/unified-inference#jev and the runnable guide at https://docs.mindshub.ai/inference/decisions/. Input, output, cached input, and cache writes are metered separately. Unsupported or out-of-range parameters are reported in response headers when MindsHub drops or clamps them. MindsHub Agents uses the same catalog, account, and balance. Q: Which API should I use? A: Use Chat Completions for chat integrations and Messages for Anthropic SDKs or Claude Code. Use the Decisions endpoint for Jev. Responses is still being upgraded, so use Chat Completions for production chat integrations. Q: Which base URL and auth field do I use? A: OpenAI SDKs use https://api.mindshub.ai/v1 with api_key. Anthropic SDKs use https://api.mindshub.ai without /v1 and must use auth_token — not api_key — so the client sends the Authorization: Bearer header. Q: How does billing work? A: There is no subscription. The free tier includes the MindsHub Air model, alias mindshub_air, and TypeSafe’s Jev decision model, alias jev. Fair use and rate limits apply. Paid usage draws from a prepaid organization balance at the rates on the pricing page. Q: Does conversation chaining work? A: No. Keep conversation history client-side and send the full history on each turn. Prompt caching makes repeated prefixes cheaper on most models; previous_response_id and store are accepted but not honored. Q: How do aliases and availability work? A: Every model has a fixed alias that names one exact version, such as gpt-6-astra, and never moves. Most lines also have a rotating alias, such as gpt, sonnet, or kimi, that resolves to the most recent version of that line MindsHub serves, so it takes upgrades without a code change. Either string goes in the model field. GET /v1/models shows the live catalog and what your organization can use. Q: Can I bring my own provider key? A: Not today. Bring-your-own-key is planned, not available. The current service uses one MindsHub key and one organization wallet. Q: How does this relate to MindsHub Agents? A: MindsHub Agents provides a workspace that uses the same model catalog. MindsHub Inference is the API for your own software. They share one account and balance. ### Download URL: https://mindshub.ai/download MindsHub Agents has desktop installers for macOS and Windows, and a .deb for Debian and Ubuntu on 64-bit x86 and 64-bit ARM. It also runs in a browser at cowork.mindshub.ai, which works on ChromeOS, mobile, and other platforms without an installer. Mobile apps are planned. Create a free account, sign in, and describe your first task. The MindsHub Air model is free within the fair-use policy and does not require a provider API key. ### About URL: https://mindshub.ai/about Jorge Torres and Adam Carrigan released the first MindsDB code in Berkeley in 2018. Today, MindsHub works to make leading AI intelligence available without locking anyone into one model, provider, or closed platform. MindsHub Agents is an agent workspace for doing complex work with AI, from research and analysis to building software. MindsHub Inference provides one way to put intelligence into agents and products while remaining free to choose models and providers. Core agent technology is open source so people can inspect, adapt, and contribute to it. The company has more than 800 contributors, 39,000 GitHub stars, and more than $50 million in funding. Q: What is MindsHub? A: MindsHub gives everyone access to leading AI models without locking them into one model or provider. MindsHub Agents, an agent workspace, applies that choice to projects ranging from research and analysis to software development. MindsHub Inference brings it to agents and products built through an API. Q: Is MindsHub the same as MindsDB? A: MindsHub is the product; MindsDB is the company behind it. The product was renamed in 2026 because it had grown beyond databases. The company and team did not change. Q: Is MindsHub open source? A: Core MindsHub technology is open source, including Anton, the agent harness behind MindsHub Agents. We believe people should be able to inspect, adapt, and contribute to the systems they rely on. Q: Who is MindsHub for? A: MindsHub Agents is for anyone working on research, analysis, reporting, software development, and other complex projects. MindsHub Inference is for building AI into agents and products. Q: Who builds MindsHub? A: MindsHub is built by MindsDB, founded in 2018 in Berkeley by Jorge Torres and Adam Carrigan. MindsDB is backed by Benchmark, Mayfield, Y Combinator, and NVIDIA, with a global open-source community of 800+ contributors. ### Use cases URL: https://mindshub.ai/use-cases MindsHub Inference lets engineering teams change models without rewriting an integration. Use a short model alias in an OpenAI- or Anthropic-compatible request. MindsHub reports any parameters it drops or clamps in response headers. Tools and agents that accept a base URL can use the same key. SetFree configures Claude Code, Codex, and VS Code for tools that otherwise hide those settings. One organization balance and usage view covers API and agent traffic. Teams can run the same evaluation set across several models, compare cost per task, and use prompt caching to reduce the price of repeated context. Failover is configured per model and published on the pricing page. Q: Do I have to change code to switch models? A: No. Change the short model alias in the request body. Unsupported parameters are dropped and out-of-range values are clamped; response headers list every change. Q: What happens if a model is unavailable? A: Failover is set per model. The pricing page lists the fallback order where one exists; some models have no fallback. Q: How do I point an agent at MindsHub? A: Set the MindsHub base URL and API key in any agent that supports both. For Claude Code, Codex, and VS Code, the open-source SetFree tool adds the gateway configuration without forking the original tool. Gemini CLI and Aider adapters are not available yet. Q: Does conversation state live on your side? A: No. Keep history in your application and send it with each turn. Most models support prompt caching for repeated prefixes. previous_response_id and store are accepted but not honored. Q: Will my streaming and tool-calling code keep working? A: Yes. Chat Completions and Messages keep their native streaming events and error signals. Tools, image input, and web search work where the chosen model and request format support them. Q: Can I bring my own provider key? A: Not today. Bring-your-own-key is planned, not available: the current service uses one MindsHub key and one organization wallet. The workspace is the exception — MindsHub Agents lets you paste in provider keys and pay those providers directly. ### Consultation URL: https://mindshub.ai/consultation Book a free 30-minute working session with a MindsHub engineer. Use it to compare models on your evaluation set, review an integration, connect an agent, examine inference costs, or set up MindsHub Agents. Sessions are offered weekly and places are limited. ### Pricing URL: https://mindshub.ai/pricing MindsHub offers Free and Pay as you go. Free costs $0 a month with no credit card: the MindsHub Air model for non-coding work, in MindsHub Agents or your own agents, and TypeSafe’s Jev decision model, under daily limits and the fair-use policy at mindshub.ai/fair-use-policy. Jev is called through the Decisions API as the alias jev with your MindsHub API key, and returns choices, scores and probabilities rather than chat replies; see https://mindshub.ai/pricing#jev. Pay as you go bills every model in the catalog at provider rates from a prepaid balance with no expiration or minimum spend, passes on caching savings, offers auto top-up with a monthly cap, and tracks usage and spend. You can also bring your own provider API keys in MindsHub Agents and pay that provider directly. The rate card lists input, output, cache, long-prompt, web-search, page-fetch, and failover pricing for each model. MindsHub Agents and MindsHub Inference use the same balance and rates. Q: What can I use for free? A: MindsHub Air for research, analysis and other non-coding work. You also get Jev for classification, routing and scoring through the Decisions API. There’s no time limit or credit card required. Daily usage limits and the fair-use policy at mindshub.ai/fair-use-policy apply. Q: Do I need a subscription to use paid models? A: No. Top up your balance and pay for what you use, with no monthly fee or minimum spend. Your balance works in both MindsHub Agents and MindsHub Inference, the API. Q: Does it cost more than going directly to the provider? A: No. You pay the provider’s published model rates. When the provider offers a discount for cached input, we pass that saving on to you. Q: Can I use my own API keys? A: Yes. Add your provider keys in MindsHub Agents and pay that provider directly. Q: How do I keep track of my spending? A: Your account shows your usage and costs. You can top up manually or turn on auto top-up with a monthly cap on automatic top-ups. Q: Do you offer discounts for higher usage? A: Contact us at mindshub.ai/contact to discuss volume pricing. ### Model rankings URL: https://mindshub.ai/models The model board covers chat models currently available through MindsHub, one row per model. Each row shows the API alias that calls it, the fixed alias naming that exact version, or a branded alias such as the MindsHub Air model or MindsHub Blaze, and compares quality, time to first answer, output speed, and measured cost per task. Quality and task cost use published Artificial Analysis measurements where available; estimated values are marked. The board also lists context length, input types, licensing, reasoning settings, and suggested uses. MindsHub Air has its own row. MindsHub Blaze is a MindsHub model alias optimized for speed, served by Cerebras. We can change the model behind the alias. Its quality, SciCode and task-cost figures are reference benchmarks, not an independent Blaze evaluation or a forecast of your MindsHub bill. Its approximate speed is a Cerebras estimate, explained in the expanded row; first-answer latency is unverified. A separate table maps each rotating alias, such as gpt, to the most recent version of its line that it serves today, and to the fixed alias of that version. For cache rates, long-prompt tiers, web search, and failover pricing, use the rate card at mindshub.ai/pricing. The free-tier section at https://mindshub.ai/models#free-tier groups the MindsHub Air model and TypeSafe’s Jev decision model. Jev is included in the MindsHub free tier, subject to the fair-use policy. Use the alias jev through POST /v1/decisions for classification, routing and scoring. Jev is listed among the included models, with its API guide at https://mindshub.ai/models#jev; it has no chat-model benchmark ranking. The LLM comparison and cost-per-task articles cover the wider market, including Claude Haiku 5.5, the Mistral Large 4 preview, GPT-6.1 Sol, Claude Sonnet 5.5, GPT-6 Sol and Luna, Claude Opus 5.5, Gemini 4 Argon, Grok 4.7, MiMo-V2.6-Pro and MiMo-V2.6-Flash. Their presence in an article does not imply availability in the MindsHub catalog. Q: Which model should I use? A: Use the task recommendations on the board. Current picks include GPT-6.1 Sol or Claude Opus 5.5 for agentic coding, Claude Opus 5.5 for hard reasoning, DeepSeek V4.1 Flash or Gemini 3.7 Flash for interactive work, and GLM-5.3 or Kimi K3 when you need open weights. Start with MindsHub Air if you do not yet have a strong preference. Q: Which models does this page cover? A: Every model currently in the MindsHub catalog, and only those models, one row per model. Each row includes the alias that calls it: the fixed alias for that exact version, or the branded alias for MindsHub Air and MindsHub Blaze. Q: What is a rotating alias? A: A rotating alias such as gpt or sonnet always resolves to the most recent version of that line MindsHub serves, so it can change without a code change on your side. Versioned model lines also have a fixed alias that names one exact version. Branded aliases such as MindsHub Air and MindsHub Blaze have no fixed counterpart. The rotating aliases table on the board maps each rotating alias to the model it serves today and to that fixed alias. Q: Why rank on cost per task instead of price per token? A: Models use different numbers of tokens and reasoning steps to finish the same task. Cost per task captures that difference. Use it to compare candidates, not as a forecast of your own bill. Q: Where do these benchmark numbers come from? A: Quality and task cost come from Artificial Analysis at each model's highest reasoning setting. A “≈” marks a reference value or estimate. Coding is the published SciCode percentage. Latency is the median wait for the first answer token, including reasoning; speed is median output throughput except for provider estimates explained in expanded rows, as on MindsHub Blaze. These source-endpoint measurements do not measure MindsHub latency, and prices come from the live MindsHub catalog. Q: At what reasoning effort were these numbers measured? A: Artificial Analysis figures use each model's highest setting. MindsHub often sends a lower default, shown when you expand a row, so actual cost may be lower. MindsHub does not publish its own per-setting scores. Q: Does this page replace the pricing page? A: No. The board shows input and output token prices for comparison. Use the pricing page for cache rates, long-prompt tiers, web search, failover order, and billing details. ### MindsHub vs MindsDB URL: https://mindshub.ai/mindshub-vs-mindsdb MindsDB began in 2018 as a way to run machine-learning models where data already lived. The product later added documents, vector search, knowledge bases, and federated queries. By 2025, the team was also building a workspace for agents that plan, use tools, run code, and produce files. In 2026, that broader product became MindsHub because the DB suffix no longer described it clearly. MindsDB remains the company. Its original query engine remains available on GitHub and is maintained by the community. The team did not change. Q: Did the company change hands or pivot? A: No. MindsHub is the product name; MindsDB remains the company behind it. The team and ownership did not change. Q: Is the MindsDB query engine going away? A: The original query engine remains available on GitHub and is maintained by the community. It is not one of the products MindsHub is building today. Q: Do old mindsdb.com URLs still work? A: Yes. Every path on mindsdb.com 301-redirects to the matching path on mindshub.ai. The redirect is in place indefinitely. Q: What does this change for existing MindsDB users? A: Nothing about your existing workloads needs to move. The open-source MindsDB project continues. If you want to delegate whole projects to open-source models and agents, that now lives under the new MindsHub surface. Q: Why was the old name confusing? A: The DB suffix fit the original database-centered product. It became misleading after the product added documents, vector search, model routing, and agent workflows. ### MindsDB Query Engine URL: https://mindshub.ai/mindsdb-query-engine The original MindsDB product is an open-source, self-hosted query engine. Register more than 200 databases, warehouses, SaaS apps, file stores, and vector databases, then query them through SQL. Knowledge Bases make documents and other unstructured sources queryable. Jobs and Triggers schedule updates or respond to data changes. The project remains available on GitHub and is maintained by the community. MindsHub now focuses on MindsHub Agents and MindsHub Inference. Q: What is MindsDB Query Engine? A: It is an open-source SQL query engine for more than 200 databases, warehouses, SaaS apps, document stores, and vector databases. It also provides Knowledge Bases, Jobs, and Triggers. Q: Is MindsDB still maintained? A: Yes. The community maintains the standalone project at github.com/mindsdb/engine. Q: How is MindsDB different from MindsHub? A: MindsDB is a self-hosted data engine that you configure and query with SQL. MindsHub provides MindsHub Inference, a hosted model API, and MindsHub Agents, an agent workspace. MindsDB and MindsHub are separate products from the same team. Q: How does the query engine compare to a traditional database? A: MindsDB does not store the source data. It provides a SQL layer across systems you already run and uses each source's native protocol. Q: How do AI agents use MindsDB? A: Agents connect through SQL or the Model Context Protocol and query connected sources with SELECT statements. MindsDB sends each query to the appropriate source handler. Q: How do Knowledge Bases work? A: A CREATE statement defines the embedding model and metadata columns. MindsDB handles chunking, vectorization, storage, and updates. Query content semantically and filter it with structured metadata. Q: Can I self-host MindsDB? A: Yes. MindsDB runs on Linux, macOS, Windows, and Docker. The source is at github.com/mindsdb/engine. Q: Which AI models does MindsDB support? A: MindsDB is model-neutral. You can plug in Anthropic, OpenAI, Google, Hugging Face, or any self-hosted endpoint — both for embeddings inside Knowledge Bases and for LLM-backed queries. Switching providers is a configuration change, not a rewrite. Q: Where can I find the documentation? A: Docs are at mindsdb.github.io/engine. Source is at github.com/mindsdb/engine. For the hosted product, see mindshub.ai or read /mindshub-vs-mindsdb for the rebrand story. ### Press Kit URL: https://mindshub.ai/press-kit MindsHub believes the best intelligence should be open to everyone. It gives everyone the freedom to choose among models and providers instead of being locked into one ecosystem. Two products put that mission into practice. MindsHub Agents is an agent workspace for completing knowledge work and developing software with open-source agent harnesses, and a choice of models. MindsHub Inference provides one API for building intelligence into agents and products while keeping the model and provider open to change. MindsHub is built by MindsDB, founded in Berkeley in 2018. Its original query engine remains on GitHub and is maintained by the community. The press kit includes SVG and PNG logos, color values, and typography guidance. Use Inter for headings and body copy, and JetBrains Mono for code and metadata. Write in plain, specific language and avoid hype. One-liner: “MindsHub gives everyone the freedom to choose among leading AI models and providers—whether they use AI to get work done or build it into products.” Boilerplate: “MindsHub is building an open foundation for working and building with AI, giving everyone the freedom to choose models and providers without being locked into one ecosystem. Its agent workspace, MindsHub Agents, supports research, analysis, content creation, and software development, with open-source agent harnesses, and a choice of models. MindsHub Inference provides that same freedom when building agents and products, with one set of controls and one bill. MindsHub is built by MindsDB, founded in Berkeley in 2018 and backed by Benchmark, Mayfield, Y Combinator, and NVIDIA.” Press inquiries: see the contact details on the press-kit page, or use the form at /contact. ### Careers URL: https://mindshub.ai/careers MindsDB is a remote-first team building MindsHub and open-source AI tools. Roles span engineering, product, design, marketing, and customer work. Benefits include unlimited PTO, health coverage or regional equivalents, mental-health support, wellbeing and development budgets, a home-office budget, company off-sites, and flexible schedules. Teams work asynchronously and write decisions down. Current openings are on the careers page. ### Support URL: https://mindshub.ai/support The MindsHub Discord at mindshub.ai/discord is open to everyone. Use it for questions, use-case advice, ideas, feature discussion, and anything open source. Use the private form at mindshub.ai/support when you need help with a specific issue or do not want to post the details publicly. Include what happened, what you expected, steps to reproduce it, the exact error, and the model in use. Commercial customers can check the Support Policy for priorities and target response times. Send sales and partnership questions through /contact, and open-source bugs through github.com/mindsdb. Q: What can I ask about in Discord? A: Ask the team and community about setup, use cases, features, ideas, models, agent harnesses, connectors, and open-source work. Q: How do I open a support ticket? A: Submit the form at mindshub.ai/support when you need help with a specific issue or prefer not to post the details publicly. Q: What should I include in a support ticket? A: Say what happened, what you expected, who is affected, when it started, how to reproduce it, the exact error, and the model in use. Q: Is there a guaranteed response time? A: Target response times and priority levels apply to customers with a commercial agreement and are set out in the Support Policy at mindshub.ai/support-policy. ### Contact URL: https://mindshub.ai/contact Use the contact form for demos, pricing, commercial support, partnerships, or general questions. MindsHub works remotely and keeps mailing addresses in San Jose and London. Use /support for product help, github.com/mindsdb for open-source work, and /careers for jobs. ## Blog ### A quicker way to check whether an agent finished URL: https://mindshub.ai/blog/jev-agent-completion-checks — 2026-09-29 Updated: 2026-10-08 Inside MindsHub Agents: how we use completion checks to catch unfinished work, and where Jev could make those decisions faster with an LLM fallback. In one of our test conversations, a user asks an agent to check last month's AWS spend. The lookup fails with a rate-limit error. The agent replies anyway: > “Last month's AWS bill came out at $214,462.28.” There is no evidence for that number anywhere in the conversation. The reply looks finished. The task isn't. This is the kind of failure we need to catch in Anton, the open-source agent harness behind MindsHub Agents. Anton reads files, runs code, searches the web, and writes answers. Sometimes it stops after doing only part of the work. Sometimes a tool fails, and it responds as if it had succeeded. We use a second, cheaper LLM to check whether Anton has finished. We wanted to find out whether a decision model could do that job faster and at a lower cost. So we tested [TypeSafe's Jev](https://docs.typesafe.ai/introduction) against our existing check on 990 generated conversations. ## Defining finished work Every Anton task that uses a tool ends with a completion check. The checker reads a compact view of the conversation and chooses what should happen next: * `COMPLETE`: the work is done, so Anton ends the task. * `WAITING`: Anton needs something from the user, so it ends the current run and waits. We also use this label for refusals of unsafe requests. * `INCOMPLETE`: Anton stopped early but can continue. We send it back to work with a note about what is missing. * `STUCK`: a blocker prevents further progress. Anton explains the blocker and stops. Those distinctions matter. A successful query that finds nothing can be complete. A refusal ends the interaction without satisfying the original request. An agent that gives up after one failed lookup may still have another way to get the answer. Jev looked like a reasonable fit for this part of the system. It returns structured decisions and probabilities. We could give it our four labels and the rules for choosing between them. ## Making the test harder to pass We needed conversations with known expected labels and no customer data. We wrote a generator with 17 scenario recipes, varying the requests, tools, errors, and wording across 16 data sources. It covered finished work, partial answers, empty query results, refusals, and failures like the unsupported AWS bill. The team reviewed the set before we relied on it. We also had a second model review 37 cases from an earlier version. It used the same rules but couldn't see our labels. It agreed with every label. It also flagged 15 cases as too easy. Some replies repeated the checker's own rules. Others practically announced that the work was unfinished. Many cases differed mainly in their numbers: once we masked those numbers, 1,000 examples became about 340 distinct conversations. We rewrote the generator. It now rejects replies that echo the rules and repeated request-and-reply pairs within a recipe. Tool results identify their sources. Access requests appear only for private sources, and missing-library errors are more realistic. The revised set contained 990 distinct examples. They still came from 17 recipes, so this was a test of known situations, with more difficult and unfinished tasks than everyday traffic. It wasn't a substitute for evaluating real conversations. ## A faster check with some telling mistakes We ran every case once through each model, for 1,980 judgments. The existing checker used the MindsHub Air model (`mindshub_air`), through Anton's production code path, including its forced tool call and output budgets. Jev received a four-way Choice using the same production rules, plus a Noul question for the check's extra yes/no field. Both received the same transcript through the production MindsHub gateway from the same client. Prompts were about 1,700 tokens, compared with roughly 2,700 in production. Timings included the gateway and network. We scored the completion labels; we didn't evaluate the LLM's written explanations or the extra yes/no field. | Measure | Current LLM check | Jev | | --- | --- | --- | | Accepted completion label | 976 / 990 (98.6%) | 982 / 990 (99.2%) | | Unsupported numbers labeled `COMPLETE` | 0 / 160 | 0 / 160 | | Wrong continue-or-stop action | 5 / 830 | 0 / 830 | | Median response time | 2.56 s | 0.78 s | | 95th-percentile response time | 3.85 s | 0.95 s | | Cost per 1,000 checks | about $0.40 | about $0.07 | Jev's median response was about three times faster, at roughly one-sixth of the cost per check. These are single-call costs, before fallbacks, calculated using the list prices when we ran the benchmark: $0.20 per million input tokens and $1.20 per million output tokens for `mindshub_air`; $0.042 per million input tokens with free output for Jev. Air's published rates have since fallen to $0.10 and $0.50. Both models rejected all 160 unsupported-number cases. For those cases, our rules accepted either `INCOMPLETE` or `STUCK`. They tested whether the checker rejected an unsupported answer, without fixing whether continuing or stopping was right. The remaining 830 cases specified a single continue-or-stop action. Jev got that action right every time in this run. Its eight label errors all swapped one stopping label for another: six requests for user input became `STUCK`, and two refusals became `COMPLETE`. Those errors could still affect what the user sees. The existing LLM made nine similar swaps between stopping labels. Its other five errors changed the action: three finished answers were sent back to work, one premature stop was accepted, and one hard blocker prompted another attempt. That was encouraging, but it left a practical problem. When Anton needs to continue, it needs a note explaining what is missing. When it is stuck, it needs an explanation for the user. Jev doesn't write those explanations. ## A shortcut for clearly finished work We could still use Jev to recognize clearly complete tasks and leave the other cases with the existing checker. To explore that, we looked at the probability Jev assigned to `COMPLETE`. Its separate [confidence field](https://docs.typesafe.ai/confidence) describes the shape of the probability distribution; it isn't a measured success rate on our task. At a `COMPLETE` probability of 0.80 or higher, Jev selected 306 cases. All 306 were correctly classified as complete. That covered 306 of the 310 finished tasks, about 99%. The two refusals it had labeled `COMPLETE` didn't reach this threshold. That suggests a useful shortcut. It doesn't establish a production threshold. The uncertain cases included refusals and successful queries that found nothing, both of which need to appear in the next evaluation. Our proposed rollout would work like this: 1. Start in shadow mode. After our data-processing review, run Jev alongside the current check and record its decisions. Keep the existing check in control while we review real traffic. 2. Choose the threshold on human-labeled conversations. Confirm it on a separate set that wasn't used to choose it. 3. Enable the `COMPLETE` shortcut only after validation. Let qualifying completions end the task. Send everything else, including Jev errors and timeouts, to the existing LLM check. We would also need to preserve the check's extra yes/no behavior, which this benchmark didn't evaluate. Giving `WAITING` its own shortcut would require separate validation. ## The savings depend on the fallback The tempting number is the difference between $0.40 and $0.07 per 1,000 checks. But a system that calls Jev first pays for Jev on every case, and for the LLM whenever it falls back. Our 306 qualifying completions were only 31% of the test set. At the rates we tested with, and with the remaining cases going to the LLM, the estimated cost would be about $0.35 per 1,000 checks. That's a saving of roughly 13%. Production has a different mix. Over two weeks in September, 73% of customer completion checks came back `COMPLETE` on the builds most customers were running. A newer release with stricter rules showed 60%, though on far fewer checks. If the threshold caught about 99% of real finished tasks as it did in the generated set, roughly 59% to 72% of checks could skip the LLM. At the tested rates, that would put the estimated cost saving at about 40% to 55%. At Air's current rates, and assuming the same token counts, the LLM side of each estimate costs at most half as much. That would put this projection below 40%, and on the test-set mix above, the shortcut would no longer save anything. Those are projections for completion checks, not measured production savings or reductions in the cost of the whole agent run. Latency needs a separate measurement. A shortcut case avoids the LLM call; a fallback case waits for both calls in sequence. Running them in parallel avoids the extra fallback wait but pays for both every time. And Anton's answer is already visible when this check runs. A faster check can help the agent finish or resume sooner. It won't make the first answer appear sooner. ## What other agent builders can use Start with the decision your code needs to make and the action each label triggers. Include cases where a confident answer has no evidence, where a successful query returns nothing, and where the agent needs the user to respond. Review the test data for clues that make the answer too easy. Then look for a narrow decision you can validate independently. For Anton, that is recognizing clearly finished work while keeping the existing checker available for everything else. Measure how often the shortcut applies, what happens when it fails, and the cost and latency of the combined system. Jev gave us a reason to test that design on real traffic. The next step is to find out whether it can recognize finished work just as reliably in long, messy conversations, where the rules are harder to apply and an unsupported answer may look perfectly reasonable. ### Jev is live on MindsHub Inference. Here’s how we’re testing it inside MindsHub Agents. URL: https://mindshub.ai/blog/jev-decision-model-agent-routing — 2026-09-24 Updated: 2026-10-08 We ran Jev, TypeSafe’s decision model, beside the MindsHub Agents router: 300 runs, decisions about 2.5 times faster on agent-bound requests, one repeated miss. Jev, TypeSafe’s decision model, is now available through [MindsHub Inference](https://docs.mindshub.ai/inference/decision-models/). After adding support, we asked the obvious follow-up: where would we use it ourselves? We started with a decision MindsHub Agents makes on every message: can it answer directly, or does it need tools? Across 300 test runs (30 hand-written prompts, each run ten times), Jev decided about 2.5 times faster than our router on agent-bound requests, never timed out, and was right on every call where it chose the agent. Accuracy was otherwise comparable: it disagreed with our router on one prompt, consistently, and both broke our own routing rule on two others. That makes Jev a credible shortcut for starting agent work sooner, not yet a proven routing upgrade. ## Why routing matters A direct answer takes one model call. A request that needs tools starts an isolated environment where the agent can browse, run code and create files. “What does HTTP 429 mean?” can be answered directly. “Search the web for our latest announcement and turn it into a one-page PDF” needs the agent. The router is a single model call. It decides the route, and on direct requests, the same call writes the answer. Jev classifies only, so it can run ahead of the router rather than replace it. Choosing the wrong path has a cost. Starting an agent unnecessarily makes a simple answer slower and more expensive. Answering directly when a request needs live information or a file can leave the task incomplete or produce an unsupported answer. ## Testing alongside our existing router Jev is running in shadow mode: it makes its own decision, but the existing router still controls what happens. MindsHub Agents does not wait for the shadow result before proceeding. We ask Jev to choose between `answer_directly` and `needs_agent`, using our routing rules. Those rules cover requests for tools, files, current information, calculations and multi-step plans. Questions about MindsHub Agents or the assistant’s runtime also go to the agent. The exact abbreviated prompt is in the appendix. We tested straightforward questions and harder cases, repeating each prompt ten times in shuffled order. Repetition helped distinguish recurring mistakes from results that changed between runs. These are synthetic tests, not a representative sample of customer conversations. The comparison isn’t fully even: the router’s prompt has been tuned over weeks while Jev’s criteria were written in a day, router timeouts count as correct when the agent fallback happens to be right, and we tested against a single router model, the MindsHub Air model, our free default. ## Faster decisions, comparable routing Across the 136 runs where both systems chose the agent and the router returned a decision, the median time was about 1.5 seconds for the router and 0.6 seconds for Jev. ![Dot plot of decision times for 30 prompts, ten runs each. Jev’s median stays near 0.6 seconds on every prompt. Where the router chose the agent, its median was 1.4 to 1.8 seconds; three of those prompts, compound interest, the division and the context-free follow-up, are drawn hollow because some of their router runs answered directly. Where it answered directly, its median was 1.6 to 3.4 seconds, because that time includes writing the answer.](/blog/jev-decision-model-agent-routing/01.webp) That is a promising gap before agent work starts. It is not yet a measured reduction in users’ waiting time. On direct requests, the router also writes the answer, so comparing its full response time with Jev’s classification time would be misleading. We scored routes against labels assigned before testing. Router timeouts fall back to the agent; the table counts that as a match when the expected route is agent. | Test set | Existing router, including fallback | Jev | | :-- | :-- | :-- | | Straightforward questions | 196/200 | 190/200 | | Harder questions | 83/100 | 81/100 | | **Total matching expected routes** | **279/300** | **271/300** | The router’s total includes 24 timeouts that fell back to the agent and matched by default. Outside the two disputed rows, both systems were about 97% right (275/280 and 270/280). Jev’s ten misses outside those rows are all on the spreadsheet prompt; the router’s five are spread across four prompts. The repeated examples explain more than the totals: - **The spreadsheet request exposed a consistent Jev mistake.** It chose a direct answer in all ten runs, even though the user requested a spreadsheet. The router chose the agent every time. - **Compound interest exposed router variability.** Jev chose the expected agent route every time. The router answered directly twice, chose the agent three times and timed out five times. - **Some harder questions exposed ambiguity in our rules.** Our policy sends even simple calculations to the agent. The router answered the seconds-in-a-week question directly every time; Jev did so in nine of ten runs. The quicksort question was also disputed because “today’s data” could mean a general question or a request to inspect a dataset. Confidence helped identify some uncertain cases, but it was not a guarantee. Jev’s median confidence on the spreadsheet was 0.60. On the disputed quicksort question, it consistently chose direct with a median confidence of 1.00. We cannot choose a reliable threshold from those examples alone. The next step is to sweep a cutoff on Jev’s returned probability against a few hundred independently labeled conversations, with a held-out set to check it. ## What could this change in MindsHub Agents? The approach we want to test is a shortcut: when Jev confidently identifies a request that needs tools, start the agent sooner. In these runs, all 161 of Jev’s `needs_agent` decisions matched the expected route, so the shortcut would not have started a single unnecessary sandbox. That distinction matters. Jev’s spreadsheet mistake would still pass through the router, which caught it in this experiment. But if Jev mistakenly sent a simple question straight to the agent, it could create an unnecessary sandbox run. We need to evaluate the combined system, not just the two classifiers separately. Running Jev first would add about 0.6 seconds before requests that still need the router. Running both concurrently could avoid that sequential delay, but their actual latency and billing effects need to be measured. Cost is another reason to investigate. Using token counts and the tested rates in the Cost section below, a million Jev calls would cost about $24, compared with about $128 for router delegation calls (about $59 at Air's current rates, assuming the same token counts). A direct router answer would cost more, but it also produces the response that Jev cannot write. Avoiding an unnecessary agent task may matter more than the classifier’s bill. One PDF task’s recorded usage, valued at our assumed model rates, came to about $0.0066 before sandbox compute. That is an illustration from one task, not a typical agent cost. ## What we learned - Jev was about 2.5 times faster than the router on agent-bound requests (0.6 seconds vs. 1.5), and the gap held across all 30 prompts. - Jev returned a classification on all 300 runs. The router timed out on 25, each time spending its full 2-second budget before falling back to the agent. - All 161 of Jev’s `needs_agent` decisions matched the expected route. The proposed shortcut acts only on those, so on this set it would not have started a single unnecessary agent session. - Jev’s one mistake was systematic: the same prompt, all ten runs, at its lowest confidence outside the two disputed rows. The router’s mistakes varied from run to run on the same prompt. - Outside the two rows where our own policy is disputed, accuracy was comparable: 275/280 for the router and 270/280 for Jev. Speed alone is not enough. The router matched slightly more expected routes, Jev repeated one clear mistake consistently, and some disagreements revealed ambiguity in our routing policy. We’re keeping Jev in shadow mode while we test the proposed shortcut on representative conversations with independently reviewed labels. The next question is whether it reduces waiting without starting unnecessary agent sessions. That is the result we need before changing how MindsHub Agents routes requests. ## Methods and limitations We tested 30 handwritten prompts, 20 straightforward and 10 harder, 10 times each, for 300 turns. Requests ran in shuffled order, two seconds apart, each in a fresh conversation. This test repeated behavior on a small set of prompts; it does not provide 300 different scenarios or test normal conversation history. Expected labels were assigned by the author before testing and were not independently reviewed. Two harder labels are disputed, and one follow-up prompt is artificial without prior conversation. Scores describe agreement with these labels, not independently established answer quality. The router used `mindshub_air`; Jev reported model version `jev-1.13.0`. Both timers ran server-side inside MindsHub Agents. Router timings include answer generation on direct turns; Jev timings include a new connection, our inference gateway, and the provider request. We did not control caching or verify the reuse of router connections. Router timeouts are excluded from its timing summaries but included in routing outcomes through the fallback. The confidence figures below are medians, not probabilities of being correct. These runs logged only confidence; the probe now logs the probability distribution as well. ### Cost Router costs use the MindsHub Air model’s published rates at the time of testing: $0.20 per million input tokens and $1.20 per million output tokens. Those rates have since fallen to $0.10 and $0.50. Jev has no MindsHub list rate; the table values it at the rate used in the test, about $0.04 per million input tokens. Both models are in the MindsHub [free tier](/pricing#free-tier), so within the [fair-use policy](/fair-use-policy) neither call is billed to MindsHub users. | Call | Measured tokens (median) | Cost per call | Per million calls | | :-- | :-- | :-- | :-- | | Router, deciding to delegate | 344 in, 49 out | $0.000128 | about $128 | | Router, writing a direct answer | 343 in, 155 out | $0.000255 | about $255 | | Jev | 570 in, no output charge | $0.000024 | about $24 | ## Appendix: full results Each row summarizes ten runs. “Matches / timeouts” reports the number of final routes matching the expected label, followed by the number of router timeouts. Timeouts fall back to the agent and can therefore count as matches. Router times exclude timeouts and include answer writing when it replies directly. All times below are milliseconds; confidence is the median across runs. Prompts are quoted as sent, so some say Cowork, the name of the MindsHub Agents workspace mode. ### Straightforward questions | # | Prompt | Expected | Router: matches / timeouts | Router ms: median (range) | Jev: matches, confidence | Jev ms: median (range) | | :-- | :-- | :-- | :-- | :-- | :-- | :-- | | 1 | What's the difference between a list and a tuple in Python? | direct | 10/10, 0 | 2860 (2627–3481) | 10/10, 1.00 | 608 (523–990) | | 2 | Explain what a race condition is in concurrent programming. | direct | 10/10, 0 | 2984 (2644–3485) | 10/10, 1.00 | 594 (544–728) | | 3 | What does HTTP status code 429 mean? | direct | 10/10, 0 | 2167 (1876–3346) | 10/10, 1.00 | 576 (530–634) | | 4 | Summarize the CAP theorem in two sentences. | direct | 9/10, 1 | 1997 (1718–2320) | 10/10, 1.00 | 602 (530–673) | | 5 | What's the time complexity of binary search? | direct | 10/10, 0 | 2192 (1616–2732) | 10/10, 1.00 | 594 (535–684) | | 6 | What's the difference between TCP and UDP? | direct | 10/10, 0 | 3048 (2592–5358) | 10/10, 1.00 | 626 (570–1092) | | 7 | Explain what idempotency means in the context of an API. | direct | 10/10, 0 | 3358 (2745–5013) | 10/10, 1.00 | 623 (550–1069) | | 8 | What is a deadlock in operating systems? | direct | 10/10, 0 | 2872 (2611–5508) | 10/10, 1.00 | 613 (553–1083) | | 9 | What's the difference between a process and a thread? | direct | 10/10, 0 | 3204 (3092–3731) | 10/10, 1.00 | 592 (556–670) | | 10 | Explain the difference between authentication and authorization. | direct | 10/10, 0 | 2076 (1977–2502) | 10/10, 1.00 | 581 (536–819) | | 11 | What's the current price of Bitcoin in USD? | agent | 10/10, 1 | 1486 (1042–1702) | 10/10, 1.00 | 590 (527–1048) | | 12 | Search the web for MindsDB's latest product announcement and summarize it in three bullet points. | agent | 10/10, 1 | 1465 (1092–1932) | 10/10, 1.00 | 606 (561–1134) | | 13 | Create a one-page PDF summary of the benefits of vector databases. | agent | 10/10, 0 | 1573 (1214–1895) | 10/10, 0.72 | 594 (548–675) | | 14 | Calculate the compound interest on $10,000 at 5% annually for 7 years. | agent | 8/10, 5 | 1567 (1256–2462) | 10/10, 0.78 | 594 (539–922) | | 15 | What's tomorrow's weather forecast for San Francisco? | agent | 10/10, 0 | 1515 (1166–1637) | 10/10, 1.00 | 606 (551–668) | | 16 | What's 847293 divided by 37, rounded to two decimal places? | agent | 9/10, 0 | 1679 (1311–2106) | 10/10, 0.75 | 579 (538–637) | | 17 | Search the web for today's top tech news headline. | agent | 10/10, 4 | 1456 (1174–1932) | 10/10, 1.00 | 610 (530–718) | | 18 | What's my current account balance? | agent | 10/10, 0 | 1552 (1281–1627) | 10/10, 1.00 | 588 (547–642) | | 19 | How many unread emails do I have right now? | agent | 10/10, 0 | 1522 (1151–1746) | 10/10, 1.00 | 586 (490–710) | | 20 | Create a spreadsheet listing the prime numbers between 1 and 100. | agent | 10/10, 0 | 1436 (1212–1986) | 0/10, 0.60 | 600 (527–689) | The router matched 196/200 expected routes, including 11 correct timeout fallbacks. It timed out 12 times; the CAP theorem timeout produced the one incorrect agent fallback. It gave three incorrect direct answers. Jev matched 190/200 routes, with all ten errors on the spreadsheet prompt. The two systems agreed on 175 of the 188 runs where the router returned a decision. In the 76 runs where both chose agent and the router returned a decision, the reported median timings were 1.52 seconds for the router (range 1.04–1.93) and 0.60 seconds for Jev (0.49–1.13). ### Harder questions | # | Prompt | Expected | Router: matches / timeouts | Router ms: median (range) | Jev: matches, confidence | Jev ms: median (range) | | :-- | :-- | :-- | :-- | :-- | :-- | :-- | | 1 | Are you GPT-4, or a different model? | agent | 10/10, 2 | 1556 (1181–1739) | 10/10, 0.97 | 595 (528–1464) | | 2 | Does Cowork support connecting to Slack? | agent | 10/10, 0 | 1430 (1331–1878) | 10/10, 0.96 | 593 (543–649) | | 3 | What's the latest stable release of PostgreSQL? | agent | 10/10, 2 | 1482 (1235–1565) | 10/10, 0.93 | 568 (512–1071) | | 4 | Roughly how many seconds are in a week? | agent by policy, disputed | 0/10, 0 | 1631 (1248–2104) | 1/10, 0.05 | 609 (521–660) | | 5 | Explain what a hash table is, and check if this repo has one in its data structures folder. | agent | 10/10, 0 | 1490 (1117–1831) | 10/10, 0.96 | 616 (540–667) | | 6 | If I were to reverse a linked list of length n, would that take O(n) or O(n log n)? | direct | 10/10, 0 | 2060 (1464–2556) | 10/10, 1.00 | 609 (539–640) | | 7 | Can Cowork read files from my Google Drive, and what's the size limit per file? | agent | 10/10, 1 | 1510 (1361–1761) | 10/10, 0.93 | 583 (555–974) | | 8 | Following up on what we discussed, is that still accurate today? | agent, ambiguous; artificial, since a fresh conversation has no prior context | 9/10, 2 | 1776 (1557–2222) | 10/10, 0.92 | 589 (533–669) | | 9 | What is Cowork's pricing, roughly, for a small team? | agent | 10/10, 2 | 1530 (1062–1908) | 10/10, 1.00 | 580 (523–1037) | | 10 | Is quicksort's worst case O(n^2) or O(n log n), and would that change if I ran it on today's data? | agent by policy, disputed | 4/10, 4 | 3206 (2934–3662) | 0/10, 1.00 | 606 (540–736) | The router matched 83/100 expected routes, including 13 correct timeout fallbacks; Jev matched 81/100. The router’s 17 direct-route mismatches occurred on the seconds-in-a-week question (ten), quicksort (six), and the context-free follow-up (one). Jev’s 19 occurred on seconds in a week (nine) and quicksort (ten). The two systems agreed on 85 of the 87 runs where the router returned a decision. The seconds-in-a-week label follows the calculation rule literally. The quicksort label assumes the user wants data inspected, an interpretation that needs review. The follow-up has no prior conversation to refer to. These annotations should be resolved before using the test set to select a production threshold. ### Routing question This is the abbreviated question used in the article. The full configuration also sends questions about MindsHub Agents and the assistant’s runtime to the agent. ```python _ROUTE_QUESTION = { "type": "choice", "instructions": ( "Classify what is required to produce the assistant's next reply. " "Return exactly one of: answer_directly or needs_agent. Classify as " "needs_agent if any condition listed for it applies; otherwise " "classify as answer_directly. When uncertain, choose needs_agent." ), "criteria": { "answer_directly": ( "The reply can be produced solely from text already in the " "conversation and stable general knowledge." ), "needs_agent": ( "The reply requires any tool use: browsing or external retrieval; " "access to an attachment, file, account, or dataset; executing or " "testing code; verifying potentially time-sensitive information; " "a calculation; or a multi-step plan." ), }, } ``` ### LLM Cost per Task: Are Cheap Models Really Cheap? URL: https://mindshub.ai/blog/llm-cost-per-task-vs-price-per-token — 2026-09-23 Updated: 2026-10-08 Compare measured LLM task costs, including Haiku 5.5, Sonnet 5.5 and GPT-6.1 Sol. See why a low token rate alone cannot tell you a job's cost. A lower token price looks like an easy saving. It stays a saving only if the model can finish the work without spending the difference on extra reasoning and retries. The bill depends on the whole attempt: how much context the model reads, how long it reasons, which tools it calls, and whether you have to run the job again. A rate card gives you the price of each token. It cannot tell you how many the job will need. Take Qwen3.8-Max (0902) and the previous-generation GPT-5.6 Sol. Their output rates are $6 and $20 per million tokens, though Sol's $20 is a [promotional rate OpenAI lists](https://developers.openai.com/api/docs/pricing) through at least November 21, 2026. On Artificial Analysis's current benchmark, however, Qwen costs $5.41 per task and Sol at max effort costs $1.99. At today's prices, Qwen's output rate is 70% lower, while its measured task cost is 172% higher. ![Qwen3.8-Max (0902) has a 70 percent lower output-token rate than GPT-5.6 Sol, but costs 172 percent more per benchmark task: $5.41 versus $1.99 at Sol's max effort.](/blog/llm-cost-per-task-vs-price-per-token/01.webp) The point is to measure how a model works through the job. Some low-price models retain a substantial cost advantage. Others consume enough tokens to lose it. ## What cost per task measures [Artificial Analysis](https://artificialanalysis.ai/models/deepseek-v4-1-flash) calculates a weighted average cost across its Intelligence Index evaluations. For each evaluation, it accounts for input, cache reads and writes, reasoning, and answer tokens, divides by the task count, and applies the evaluation's index weight. That is more useful than token price alone, but it still measures benchmark attempts. It does not divide spending by the number of results your team would accept, or include your staff's review time. For a model shortlist and input capabilities, use our [LLM comparison](/blog/navigating-the-llm-landscape-a-comparative-analysis-of-leading-large-language-models). This article focuses on the bill. ## The October 2026 cost snapshot The table uses **Intelligence Index v4.3.2**, checked October 8, 2026, and the same models and settings as the comparison article. Rows are sorted by rounded score, highest first; ties go to the lower cost. Token prices are US dollars per million uncached input and output tokens. We show the highest published effort, or the single published reasoning row where no effort is named. The snapshot adds Claude Haiku 5.5, released October 7, and the public preview of Mistral Large 4. Two existing rows also have new task costs: Sonnet 5.5, after Anthropic's cut to its cache-read price, and Grok 4.6. Google announced Gemini 4 Argon on September 30 and has so far limited access to trusted cyber defenders and testers. It appears at the only setting Artificial Analysis publishes, at Google's introductory rates. These are reference settings; the largest effort label does not guarantee the best result or establish a maximum bill.
ModelPriceper 1M · in / outIntelligenceindex v4.3.2Cost per taskbenchmark average
Claude Opus 5.5max, with fallback$4 / $2058$5.98
Claude Sonnet 5.5max, with fallback$2 / $1056$5.46
Gemini 4 Argonhigh, introductory pricing, limited access$2 / $1053$1.99
GPT-6 Astramax$10 / $5053$3.26
Claude Fable 5.1max, with fallback$10 / $5053$7.63
GPT-6.1 Solmax$2 / $1052$0.72
Claude Opus 5max$5 / $2551$5.86
Claude Fable 5max, with fallback$10 / $5050$8.75
GPT-6 Solmax$2 / $1048$1.04
Muse Spark 1.3max, Standard pricing$1.25 / $4.2548$1.60
GPT-5.6 Solmax$4 / $20*47$1.99
MiMo-V2.6-Propublished reasoning row$0.435 / $0.8746$0.13
Grok 4.7xhigh$2 / $646$3.74
GLM-5.3max$1.4 / $4.445$2.01
Qwen3.8-Max (0902)published reasoning row$2 / $645$5.41
Grok 4.6xhigh$2 / $644$1.75
Kimi K3max$3 / $1544$2.00
Claude Haiku 5.5max, prompts up to 100K tokens$0.10 / $0.5043$0.21
GLM-5.3-Flashpublished reasoning row$0.15 / $0.542$0.25
GPT-5.6 Terramax$2 / $1242$1.40
Gemini 3.8 Flashhigh, introductory pricing$0.75 / $3.7541$1.24
Qwen3.8-Flash-Nextpublished reasoning row$0.15 / $0.4740$0.37
DeepSeek V4.1 Flashmax, peak token rates$0.3 / $1.239$0.27
MiMo-V2.6-Flashpublished reasoning row$0.14 / $0.2838$0.06
GPT-6 Lunamax$0.10 / $0.5038$0.07
Mistral Large 4published reasoning row, public preview$1.36 / $4.1838$1.13
Claude Sonnet 5max$2 / $1038$5.09
GPT-5.6 Lunamax$0.2 / $1.237$0.18
DeepSeek V4 Pro 0813max, peak token rates$1.32 / $3.9636$0.67
The table uses provider rates recorded by Artificial Analysis, including Standard pricing for Muse and peak token rates for DeepSeek. Cached input, time-of-day discounts, batch processing, long prompts, and tool fees can change your bill. Three rows carry a time-limited price. Gemini 3.8 Flash's $0.75 / $3.75 is introductory through December 31, 2026 and rises to $1.50 / $7.50 on January 1, 2027. Gemini 4 Argon's $2 / $10 is introductory with no end date announced, and Google says $4 / $20 applies afterward. The asterisk on GPT-5.6 Sol marks a promotional rate: [OpenAI lists $4 / $20](https://developers.openai.com/api/docs/pricing) at least through November 21, 2026. Mistral Large 4 appears at its list rates, although Mistral took 50% off for two weeks from its October 6 launch. Claude Haiku 5.5's rates apply only to prompts up to 100,000 tokens; [a longer prompt pays](https://platform.claude.com/docs/en/about-claude/pricing) $0.50 / $2.50 on the whole request. Check the provider terms for the requests you will send; [MindsHub's rate card](/pricing) is separate. ## GPT-6 Sol and Luna: lower rates and measured task costs [OpenAI's new Sol and Luna releases](https://openai.com/index/introducing-gpt-6-sol-and-luna/) cut the price of each token. Sol costs $2 input / $10 output per million tokens, half the promotional $4 / $20 for GPT-5.6 Sol. Luna costs $0.10 / $0.50, versus $0.20 / $1.20 for GPT-5.6 Luna. Artificial Analysis now measures [Sol at 48 and $1.04 per task](https://artificialanalysis.ai/models/gpt-6-sol), against 47 and $1.99 for GPT-5.6 Sol. [Luna scores 38 at $0.07](https://artificialanalysis.ai/models/gpt-6-luna), against 37 and $0.18 for GPT-5.6 Luna. All four use max effort. These are new measurements, not the old task costs multiplied by a price cut. The opening example remains a comparison with the previous-generation Sol. OpenAI released [GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) on [September 29](https://developers.openai.com/api/docs/changelog) in its API as `gpt-6.1-sol`, listed at $2 input / $10 output per million tokens for prompts up to 272K input tokens, with higher rates above that. [Artificial Analysis's entry](https://artificialanalysis.ai/models/gpt-6-1-sol) scores 52 at $0.72 per task at max, at the same $2 / $10 list rates as GPT-6 Sol, though its cached input costs $0.10 per million instead of $0.20. That is about 31% below GPT-6 Sol’s measured task cost. Artificial Analysis's cost breakdown shows where the saving came from: input cost per task falls from $0.73 to $0.34, almost all of it in cache reads (from $0.51 to $0.12: half the price, on about half as many cached tokens), while output cost rises from $0.31 to $0.38, because its weighted output per benchmark task is about 23% higher (about 38k tokens against 31k) at the same $10 rate. ## Claude Haiku 5.5 and GPT-6 Luna: same rates, different bills Claude Haiku 5.5 and GPT-6 Luna list identical token rates: $0.10 per million input tokens and $0.50 per million output tokens. At max effort, [Artificial Analysis](https://artificialanalysis.ai/models/claude-haiku-5-5) measures Haiku 5.5 at 43 and $0.21 per task, and Luna at 38 and $0.07. The same token rates produce three times the benchmark cost. The difference is how many tokens each model uses. Haiku 5.5 writes about 162k output tokens per task at max, against about 50k for Luna, and re-reads about three times as much cached context. Artificial Analysis's breakdown puts its input and cache cost at $0.13 per task against $0.04, and its output cost at $0.08 against $0.03. It also scores five points higher, so the useful question is whether those points change the results you accept. Effort narrows the gap: Haiku 5.5's xhigh row scores 41 at $0.12, and its high row scores 38 at $0.08, level with Luna at max for about the same cost. Anthropic's $0.10 / $0.50 also applies only to prompts up to 100,000 tokens. A longer prompt pays five times as much on the whole request, and cached tokens count toward that limit, so long-context work needs its own estimate. ## Where the newer low-cost models fit **MiMo-V2.6-Pro** reaches 46 at $0.13 per benchmark task, using the rates recorded by [Artificial Analysis](https://artificialanalysis.ai/models/mimo-v2-6-pro). **DeepSeek V4.1 Flash** reaches 39 at $0.27. **GLM-5.3-Flash** reaches 42 at $0.25, while **Qwen3.8-Flash-Next** reaches 40 at $0.37. **MiMo-V2.6-Flash** reaches 38 at $0.06, level with GPT-6 Luna's 38 at $0.07. Artificial Analysis calls it slower than average and very verbose, so its low task cost comes from its $0.14 / $0.28 rates, not from short answers. These are useful candidates for a budget evaluation, especially when their supported input types match the work. Two details keep the comparison honest. First, a model name can hide a release change: the current Qwen3.8-Max (0902) row scores 45 at $5.41, while the older 0803 row had different measurements. Flash-Next is a separate model, not a lower effort setting. Second, this is a new DeepSeek checkpoint. The older V4 Flash task cost does not describe V4.1 Flash, even when an API alias moves to the new version. V4 Pro remains available separately. See the [DeepSeek section of the comparison](/blog/navigating-the-llm-landscape-a-comparative-analysis-of-leading-large-language-models#deepseek-v41-flash-replaces-the-older-flash-api) for the current routing details. ### A new version can change the bill without changing token prices Grok 4.7 and Grok 4.6 both list $2 input / $6 output per million tokens. At xhigh, their task costs are $3.74 and $1.75, respectively. The newer model scores 46 against 44, but costs more than twice as much per benchmark task. Its [launch announcement](https://x.ai/news/grok-4-7) describes changes aimed at longer coding and knowledge-work tasks; test whether those changes improve the results you accept. Opus 5.5 offers a different comparison. Its $4 / $20 token rates are 20% below Opus 5's $5 / $25, while its max-effort task cost is about 2% higher: $5.98 against $5.86. Its score rises from 51 to 58. The 5.5 result includes the default fallback, so record that configuration with the comparison. [Sonnet 5.5](https://artificialanalysis.ai/models/claude-sonnet-5-5) shows how little of a token discount can reach the bill. Its $2 / $10 rates are half Opus 5.5’s, but its max-effort task cost is only about 9% lower: $5.46 against $5.98. It scores 56 against 58. Both results include the default fallback. ### A cache-read price can move the bill on its own On October 7, Anthropic [halved Sonnet 5.5's cache-read price](https://platform.claude.com/docs/en/release-notes/overview), from $0.20 to $0.10 per million tokens, and left its input and output rates unchanged. Artificial Analysis's measured task cost fell from $7.62 to $5.46 at the same score of 56. Cache reads still account for about $2.21 of that, because agentic tasks re-read a growing context at each step. If your workload caches heavily, compare cache-read prices as carefully as the headline rates. ### Try a lower effort setting Grok 4.7 xhigh and high both round to 46, at $3.74 and $2.73 per task. Opus 5.5 max scores 58 at $5.98; high scores 54 at $1.82. GPT-6 Astra max scores 53 at $3.26, against 52 and $2.31 at xhigh. GPT-6.1 Sol max scores 52 at $0.72; high scores 50 at $0.32. Sonnet 5.5 makes an especially large move: max scores 56 at $5.46, xhigh scores 52 at $2.01, and high scores 47 at $0.88. The cheaper setting gives up measured capability, so judge the saving against your acceptance criteria. Those tradeoffs give you a useful experiment: run your tasks at both settings. Keep the extra reasoning where it improves accepted results, and lower it where it only adds time and cost. ### Read discounted tiers as contracts Gemini 4 Argon is the clearest recent case. [Artificial Analysis](https://artificialanalysis.ai/models/gemini-4-argon) scores it 53 at $1.99 per task. GPT-6 Astra also rounds to 53, though Argon is just below it before rounding. That cost uses Google's [announced introductory rates](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/) of $2 / $10. Google says $4 / $20 applies afterward. At those rates the same run costs $3.98, about 22% more than Astra's $3.26 at its list rates. Both of Argon's introductory rates are 80% below Astra's, yet it averages [about 62k output tokens per task against about 27k](https://artificialanalysis.ai/articles/gemini-4-argon-google-top-three-labs), so its introductory task cost is 39% lower, not 80%. The saving comes from the token price, not from using fewer tokens. GPT-6.1 Sol has the same $2 / $10 rates and costs $0.72 per task. As of October 8, access is limited to trusted cyber defenders in Google's Fairwind Program, with no date for wider access. Artificial Analysis lists a single setting, high, so there is no measured cheaper effort level to compare. Check access and billing terms before planning around Argon's price. Meta's [Muse Contributor option](https://dev.meta.ai/docs/pricing-rate-limits/) charges $0.10 per million input tokens and $0.20 per million output tokens in exchange for permission to use prompts and completions in training. That can change which data you are allowed to send. The $1.60 Muse result above uses Standard pricing; it is not a measured Contributor result. DeepSeek's [peak, off-peak, and cache rates](https://api-docs.deepseek.com/quick_start/pricing/) are another reason to record billing conditions with an evaluation. A discount matters only when your actual requests qualify for it. ## MindsHub free tier The [MindsHub free tier](/pricing#free-tier) includes selected models at no charge. Currently included: the **MindsHub Air model** and **Jev**. No credit card is required; [fair use and daily rate limits apply](/fair-use-policy). ## Measure the cost of results you can use Start with ten representative tasks as a pilot. Include the documents, instructions, and tool access the model will have in practice, along with a few cases you know are difficult. 1. **Set acceptance criteria before running the models.** For extraction, that might mean every required field is correct. For a code change, it may mean the tests pass and a reviewer accepts the patch. 2. **Run two or three candidates.** Record the model version, reasoning setting, prompts, and billing conditions. Repeat tasks where inconsistent results would matter. 3. **Count the whole workflow.** Include failed attempts, retries, tool charges, and any follow-up model calls. Record human review time separately so a cheap but demanding model does not appear free to operate. 4. **Divide total spend by accepted results.** If you spend $12 across all attempts and accept eight results, the cost is $1.50 per accepted result. If none pass, the model has not established a usable cost for that workflow. Ten tasks can reveal a large mismatch; they cannot establish a dependable success rate. Expand the evaluation before a consequential rollout, using the process in our [model selection guide](/blog/which-llm-to-choose-12-key-aspects-to-consider-when-building-ai-solutions). Re-run it when the model, alias, prompt, or pricing changes. Keep the evaluation set and scoring rules outside any one agent workspace; the [workspace migration checklist](/blog/manus-alternative-ai-workspace-migration#the-ai-workspace-migration-checklist) covers the context and workflow details to preserve. --- *[MindsHub Agents](/download) provides a workspace with a choice of models and Anton, an open-source agent harness. [MindsHub Inference](/unified-inference) gives developers access to the MindsHub model catalog through one API. Check [model availability](/models) and [MindsHub pricing](/pricing) for the service you plan to use.* ### The Best LLMs in 2026: A Plain-English Comparison URL: https://mindshub.ai/blog/navigating-the-llm-landscape-a-comparative-analysis-of-leading-large-language-models — 2026-09-23 Updated: 2026-10-08 Compare Claude Opus 5.5, Sonnet 5.5, Haiku 5.5, GPT-6.1 Sol, Mistral Large 4, and other leading LLMs by capability, token price, and measured cost per task. The model at the top of the leaderboard may be too expensive for everyday work. The cheapest API may need more attempts to get the answer right. That leaves a practical question: which models deserve a test on your work? A team reviewing contracts needs different evidence from one building a coding agent or processing thousands of images. This guide compares the main model families and the costs behind their headline prices. The October 8 snapshot adds Anthropic's **Claude Haiku 5.5**, released October 7, and the public preview of **Mistral Large 4**. It reflects Anthropic's cheaper cache reads for **Claude Sonnet 5.5** and also covers **GPT-6.1 Sol**, **Gemini 4 Argon** (still in limited access), **GPT-6 Sol and Luna**, **Claude Opus 5.5**, **Grok 4.7**, **MiMo-V2.6-Pro**, and **MiMo-V2.6-Flash**, and explains where the free MindsHub Air model and Jev fit. Scores use [Artificial Analysis's Intelligence Index v4.3.2](https://artificialanalysis.ai/leaderboards/models); they should not be compared with scores from earlier index versions. ## Where to start testing - **Difficult reasoning and coding:** compare Claude Opus 5.5, Claude Sonnet 5.5, and GPT-6 Astra. They are among the leaders in this snapshot, but their task costs differ substantially. Gemini 4 Argon also scores 53, but access is limited to trusted cyber defenders for now, so treat it as a name to watch rather than a model to run today. - **Everyday work:** test GPT-6.1 Sol for coding and multi-step workflows, and GPT-6 Luna or Claude Haiku 5.5 for focused, high-volume tasks. Compare them at the effort level you would use in production. - **Mixed-media input:** Gemini 3.8 Flash accepts text, images, audio, and video. Muse Spark 1.3 and Qwen3.8-Flash-Next are also candidates when you need image or video input. - **Lower-cost text and image work:** put MiMo-V2.6-Pro, MiMo-V2.6-Flash, DeepSeek V4.1 Flash, and GLM-5.3-Flash on the shortlist. All four have downloadable, MIT-licensed weights. - **More control over deployment:** compare GLM-5.3 and Kimi K3 as well. Check their licences and hardware requirements before choosing to host them yourself. Mistral says Large 4's weights will follow by the end of October, but it has not named their licence. These are starting points. Run the same tasks through two or three candidates and inspect the results before committing. ## Models at a glance Prices are US dollars per million uncached input and output tokens. The benchmark setting appears beneath each model name. We use the highest published reasoning effort, including Grok's xhigh row. When a source publishes one reasoning row without an effort label, we say so. Index scores are rounded to whole numbers, so models with the same score can still differ slightly. All figures were checked October 8, 2026. Cost per task is the benchmark's weighted average token cost. It is neither a spending limit nor the cost of a result your team has accepted. The suggestions in the third column are our assessment of what to test, based on the capabilities and measurements discussed below.
ModelTypeTest forQualityintelligence index v4.3.2Priceper 1M · in / outPer taskbenchmark average
GPT-6 AstraOpenAI · maxClosedComplex work across code, browsers, and documents53$10 / $50$3.26
GPT-6.1 SolOpenAI · maxClosedCoding and multi-step agent work52$2 / $10$0.72
GPT-6 SolOpenAI · maxClosedAn earlier Sol reference for existing GPT-6 Sol workflows48$2 / $10$1.04
GPT-6 LunaOpenAI · maxClosedFocused text and image tasks at volume38$0.10 / $0.50$0.07
GPT-5.6 SolOpenAI · max, promotional pricingClosedGeneral coding, analysis, and professional work47$4 / $20$1.99
GPT-5.6 TerraOpenAI · maxClosedAn upgrade reference for existing GPT-5.6 workflows42$2 / $12$1.40
GPT-5.6 LunaOpenAI · maxClosedRoutine tasks at high volume37$0.2 / $1.2$0.18
Claude Opus 5.5Anthropic · max, with fallbackClosedDifficult reasoning, coding, and document work58$4 / $20$5.98
Claude Sonnet 5.5Anthropic · max, with fallbackClosedReasoning and coding with effort tuned to the task56$2 / $10$5.46
Claude Fable 5.1Anthropic · max, with fallbackClosedDifficult reasoning, coding, and review53$10 / $50$7.63
Claude Opus 5Anthropic · maxClosedComplex coding and analysis below Fable token rates51$5 / $25$5.86
Claude Fable 5Anthropic · max, with fallbackClosedAn older reference for existing Fable workloads50$10 / $50$8.75
Claude Haiku 5.5Anthropic · max, prompts up to 100K tokensClosedHigh-volume tasks with an adjustable effort setting43$0.10 / $0.50$0.21
Claude Sonnet 5Anthropic · maxClosedShorter Claude workflows, with effort tuned to the task38$2 / $10$5.09
Gemini 4 ArgonGoogle · high, introductory pricing, limited accessClosedA model to watch once access opens beyond trusted cyber defenders53$2 / $10$1.99
Gemini 3.8 FlashGoogle · high, introductory pricingClosedText, image, audio, and video input41$0.75 / $3.75$1.24
Muse Spark 1.3Meta · max, Standard pricingClosedLong agent workflows with text, images, and video48$1.25 / $4.25$1.60
Grok 4.7SpaceXAI · xhighClosedLong coding and research workflows with web and X tools46$2 / $6$3.74
Grok 4.6SpaceXAI · xhighClosedWork that uses web and X search tools44$2 / $6$1.75
GLM-5.3Z AI · maxOpenText and coding work with downloadable weights45$1.4 / $4.4$2.01
GLM-5.3-FlashZ AI · published reasoning rowOpenLow-cost text and image tasks42$0.15 / $0.5$0.25
Kimi K3Moonshot AI · maxOpenLong coding workflows and image input44$3 / $15$2.00
MiMo-V2.6-ProXiaomi · published reasoning rowOpenLow-cost text, image, audio, and video tasks46$0.435 / $0.87$0.13
MiMo-V2.6-FlashXiaomi · published reasoning rowOpenVery low-cost text, image, audio, and video tasks where speed matters less38$0.14 / $0.28$0.06
Qwen3.8-Max (0902)Alibaba · published reasoning rowClosedMultimodal work through a hosted API45$2 / $6$5.41
Qwen3.8-Flash-NextAlibaba · published reasoning rowOpenLower-cost text, image, and video tasks40$0.15 / $0.47$0.37
DeepSeek V4.1 FlashDeepSeek · max, peak token ratesOpenLow-cost text and image work with MIT-licensed weights39$0.3 / $1.2$0.27
DeepSeek V4 Pro 0813DeepSeek · max, peak token ratesOpenExisting V4 Pro text and reasoning workflows36$1.32 / $3.96$0.67
Mistral Large 4Mistral AI · published reasoning row, public previewAPI onlyEarly text and image evaluation before its weights ship38$1.36 / $4.18$1.13
### Pricing and access details The token rates shown are those recorded by Artificial Analysis, checked October 8, 2026. They are developer API rates; consumer subscriptions and MindsHub's own rate card are separate. - **OpenAI:** the list prices in the table apply to prompts up to 272K input tokens. Above that, the whole request costs twice the input rate and 1.5 times the output rate ([OpenAI pricing](https://developers.openai.com/api/docs/pricing)). GPT-5.6 Sol's $4 / $20 is a promotional rate that OpenAI says is available at least through November 21, 2026. GPT-6.1 Sol also has an Ultrafast mode, added October 8, that streams faster at six times the standard rates. Check caching terms and tool fees as well. - **Anthropic:** Claude Haiku 5.5's $0.10 / $0.50 applies to prompts up to 100,000 tokens. A longer prompt pays $0.50 / $2.50 on the whole request, and cached tokens count toward that threshold ([Anthropic pricing](https://platform.claude.com/docs/en/about-claude/pricing)). On October 7, Anthropic halved Claude Sonnet 5.5's cache-read price to $0.10 per million tokens without changing its input or output rates. - **Grok:** long prompts can cost more. Check the provider's current context thresholds, caching terms, and tool fees. - **Gemini:** Google calls the 3.8 Flash rate [introductory pricing](https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/) through December 31, 2026, and lists $1.50 input / $7.50 output from January 1, 2027. For [Gemini 4 Argon](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/), Google has announced an introductory $2 / $10 that rises to $4 / $20, and has not said when the introductory period ends. Artificial Analysis's $1.99 task cost uses the introductory rates and puts the same task at $3.98 at the standard rates. - **Muse:** the table uses Standard pricing. Contributor has different data-use terms and is discussed below. - **Mistral:** the table uses Large 4's list rates. Mistral took 50% off for two weeks from the October 6 launch ([Mistral's changelog](https://docs.mistral.ai/getting-started/changelog)). - **DeepSeek:** the V4.1 Flash row uses peak rates of $0.30 input / $1.20 output. Its off-peak rates are $0.15 / $0.60, and cached input has a separate rate. V4 Pro also has peak and off-peak pricing. Check the [current rate card](https://api-docs.deepseek.com/quick_start/pricing/) for the applicable hours and rates. - **Open weights:** download access does not promise a particular licence, hosting price, or fit on your hardware. Review the exact checkpoint and host. This article covers a wider set of models than MindsHub serves. Use the [MindsHub model board](/models) to check availability and [pricing](/pricing) for MindsHub billing. ## What each model family offers ### OpenAI: Astra, Sol, and Luna [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra) is OpenAI's model for its hardest work across code, browsers, and professional files. At max effort it scores 53 in this snapshot, alongside Fable 5.1 and Gemini 4 Argon, at $3.26 per benchmark task. That makes it a useful candidate for complicated workflows with several tools and review steps. [GPT-6 Sol and Luna](https://openai.com/index/introducing-gpt-6-sol-and-luna/) extend that family at lower token prices. Sol lists $2 input / $10 output per million tokens, half GPT-5.6 Sol's promotional rates. Luna lists $0.10 / $0.50, down from $0.20 / $1.20. Both accept text and image input. Luna is worth testing for focused tasks at volume. At max effort, [Sol scores 48 at $1.04 per benchmark task](https://artificialanalysis.ai/models/gpt-6-sol), while [Luna scores 38 at $0.07](https://artificialanalysis.ai/models/gpt-6-luna). GPT-5.6 Sol scores 47 at $1.99, and GPT-5.6 Luna scores 37 at $0.18. Those older rows remain as upgrade references. The newer models cost less on this benchmark; test whether that advantage holds for results your team accepts. [GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol), which OpenAI released in its API as gpt-6.1-sol on [September 29](https://developers.openai.com/api/docs/changelog), lists the same $2 input / $10 output rates as GPT-6 Sol for prompts up to 272K input tokens, with cached input at $0.10 instead of $0.20 per million. [Artificial Analysis](https://artificialanalysis.ai/models/gpt-6-1-sol) scores it 52 at $0.72 per task at max effort, against 48 at $1.04 for GPT-6 Sol, so it scores higher and costs about 31% less. Cost per task reflects cached-input pricing and the tokens each model uses, not only the list rates, so confirm the saving on your own workload. GPT-6.1 Sol also sits one point below Astra at under a quarter of Astra's task cost. Effort is part of the choice. Astra's xhigh row scores 52 and costs $2.31 per task, against 53 and $3.26 at max, and GPT-6.1 Sol's xhigh row scores 51 at $0.39, against 52 and $0.72. Compare the settings on your own evaluation set before paying for the extra reasoning. ### Claude: strong results, and effort decides the cost [Claude Opus 5.5](https://artificialanalysis.ai/models/claude-opus-5-5) leads this snapshot at 58 and $5.98 per benchmark task at max effort with the default fallback. Its high-effort row scores 54 at $1.82. Those measurements make effort a practical part of the choice, especially for recurring code and document work. [Claude Sonnet 5.5](https://artificialanalysis.ai/models/claude-sonnet-5-5) scores 56 at $5.46 per task at max with fallback. Its $2 / $10 token rates are half Opus 5.5’s, yet its measured task cost is only about 9% lower. That figure reflects Anthropic's October 7 cut to Sonnet 5.5's cache-read price; at the old price, Artificial Analysis measured $7.62. Xhigh scores 52 at $2.01; high scores 47 at $0.88. Choose the setting as carefully as the model. [Claude Haiku 5.5](https://www.anthropic.com/claude-haiku-5-5), released October 7, is Anthropic's small model for high-volume work and the first Haiku with an adjustable effort setting. It accepts text and image input with a one-million-token context window. At max effort, [Artificial Analysis](https://artificialanalysis.ai/models/claude-haiku-5-5) scores it 43 at $0.21 per task, against 17 for Haiku 4.5. It lists the same $0.10 / $0.50 rates as GPT-6 Luna and scores five points higher, but costs three times as much per task because it uses about three times as many tokens: it writes about three times as many output tokens and re-reads about three times as much cached context. Its xhigh row scores 41 at $0.12, and high scores 38 at $0.08. At max, its median wait for the first answer token is about five minutes, so test lower settings for anything a person waits on. Fable 5.1 remains at 53 and $7.63, while Opus 5 scores 51 at $5.86. Sonnet 5 has lower token rates, but its max-effort task cost is still $5.09. We retain the older rows for existing users comparing an upgrade. Opus 5.5, Sonnet 5.5, and Fable measurements include a default fallback; [Artificial Analysis explains the Fable setup](https://artificialanalysis.ai/articles/claude-fable-5-1) in an article that uses an earlier index version, so its scores differ from the table. Treat each result as a measurement of the named configuration. ### Gemini: Flash for mixed input, Argon in limited access [Gemini 3.8 Flash](https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/) accepts text, images, audio, and video. That range is useful when a workflow combines recordings, screenshots, and documents. Its high-effort row scores 41 at $1.24 per benchmark task. Gemini 3.8 Flash's broad score is below the leaders, so check the tasks that matter to you. Google also notes that difficult work can use more tokens and tool calls than with 3.7 Flash. Include those calls in the evaluation, along with the introductory pricing deadline. [Gemini 4 Argon](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/) is not broadly available yet. Google announced it on September 30 and is rolling it out to trusted cyber defenders through its Fairwind Program, with paid API customers and Google AI Ultra subscribers next and no date given. [Artificial Analysis](https://artificialanalysis.ai/models/gemini-4-argon) lists a single Argon row, high, which it calls the highest effort available. It scores 53 on index v4.3.2, the same rounded score as Astra and Fable 5.1 (52.56 against 52.67 and 53.35 before rounding) and below Opus 5.5 and Sonnet 5.5, at $1.99 per task on Google's introductory rates, or $3.98 at the standard $4 / $20. Argon averages about 62k output tokens per task against about 27k for Astra at max, so its low task cost comes from the discounted token price, not shorter answers. Google describes image and long-video understanding but has not published a list of input types, and Artificial Analysis has no speed or latency figure for it yet. Google's own launch table, which uses benchmarks it chose and many results it computed itself, shows Argon leading outright on 13 of its 19 rows and tying one, against Astra, Fable 5.1, and Opus 5.5. Artificial Analysis's independent index does not show Argon ahead of Opus 5.5, Sonnet 5.5, or Fable 5.1. Google also says it is still strengthening safeguards before a broad release. ### Muse: long agent workflows, with a separate Contributor option [Muse Spark 1.3](https://research.meta.ai/blog/introducing-muse-spark-1-3) supports text, image, and video input. At max effort, its score of 48 and Standard task cost of $1.60 make it worth comparing for long coding and agent workflows. It is a closed model; Meta's history with Llama does not mean Spark weights are downloadable. Meta's [Contributor option](https://dev.meta.ai/docs/pricing-rate-limits/) charges $0.10 per million input tokens and $0.20 per million output tokens in exchange for permission to use submitted prompts and completions in training. Treat the data terms as part of the price. The benchmark figure here uses Standard and does not establish a Contributor task cost. ### Grok: search access and an effort setting to test [Grok 4.7](https://x.ai/news/grok-4-7) adds a newer candidate for long coding and knowledge-work tasks. It accepts text and images, with a 500k context window and access to the provider's web and X search tools. Search can supply current information; the model still needs to check and use it correctly. At xhigh, Grok 4.7 scores 46 and costs $3.74 per benchmark task. High also rounds to 46 at $2.73. Grok 4.6 remains at 44 and now costs $1.75 at xhigh. Both generations list $2 input / $6 output per million tokens, yet the newer model costs more than twice as much per task. The table uses the standard 4.7 API, not its separately priced fast variant. ### GLM and Kimi: downloadable models with different costs [GLM-5.3](https://artificialanalysis.ai/models/glm-5-3) is a text model with a score of 45 and a task cost of $2.01. [GLM-5.3-Flash](https://artificialanalysis.ai/models/glm-5-3-flash) adds image input, uses an MIT licence, and reaches 42 at $0.25 per task. The larger model's custom licence and higher cost deserve separate consideration. [Kimi K3](https://artificialanalysis.ai/models/kimi-k3) supports image input and long coding workflows. Its max-effort score is 44 at $2.00 per task. Downloadable weights give you a hosting option, but its custom licence and hardware needs still determine whether that option works for your team. ### MiMo: two low-cost multimodal candidates [MiMo-V2.6-Pro](https://artificialanalysis.ai/models/mimo-v2-6-pro) scores 46 at $0.13 per benchmark task, using the API rates recorded by Artificial Analysis: $0.435 input / $0.87 output per million tokens. It is worth testing when cost matters, though one broad score cannot show whether it handles your tasks reliably. Xiaomi's [Pro-RL model card](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL) lists text, image, audio, and video input, a one-million-token context window, and MIT-licensed weights. With 1.02 trillion total parameters, it needs substantial hardware to self-host. [MiMo-V2.6-Flash](https://artificialanalysis.ai/models/mimo-v2-6-flash) scores 38 at $0.06 per task on $0.14 input / $0.28 output rates, the lowest task cost in the table. Artificial Analysis calls it slower than average and very verbose, so the low cost comes from the low token rates rather than short answers. Xiaomi's [Flash-RL model card](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-RL) lists text, image, audio, and video input, a one-million-token context window, and MIT-licensed weights, with 309 billion total parameters and 15 billion active. ### Qwen: distinguish Max from Flash-Next [Qwen3.8-Max (0902)](https://artificialanalysis.ai/models/qwen3-8-max) is a proprietary multimodal API. [Qwen3.8-Flash-Next](https://artificialanalysis.ai/models/qwen3-8-flash-next) has open weights, text, image, and video input, and a 256k context window. The current 0902 Max release scores 45 at $5.41 per task; Flash-Next scores 40 at $0.37. The older 0803 Max release has different measurements, so record the release as well as the model name. Context windows, supported input types, and task behavior also differ. The downloadable Qwen3.8 2.4T A95B checkpoint is another distinct model; it is not the Max API. ### DeepSeek: V4.1 Flash replaces the older Flash API [DeepSeek V4.1 Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash) launched on September 10 with native text and image input, a one-million-token context window, and MIT-licensed weights. Artificial Analysis measures it at 39 and $0.27 per task at max effort. That puts it close in task cost to GLM-5.3-Flash, with a different capability profile to test. DeepSeek's [current API documentation](https://api-docs.deepseek.com/quick_start/pricing/) names the new model **deepseek-flash**. The older V4 Flash and Flash Vision API names now route to V4.1 Flash. V4 Pro remains available: the current documentation withdraws the earlier plan to replace it after September 14 and says its billing will stay unchanged. Check the model behind an alias when comparing older results. The name Flash does not mean it will run on a laptop. Its model card lists 552 billion backbone parameters plus a 196-billion-parameter Engram memory component; self-hosting needs a suitable serving setup and hardware budget. ### Mistral: Large 4 in public preview [Mistral Large 4](https://mistral.ai/news/mistral-large-4/) entered public preview on October 6. Mistral calls it its largest model: a mixture-of-experts with about 1 trillion total parameters and 52 billion active per token, and it reads images as well as text. Mistral's [model card](https://docs.mistral.ai/models/mistral-large-4-0) lists a one-million-token context window, while Artificial Analysis and OpenRouter record 524,288 tokens for the preview API. [Artificial Analysis](https://artificialanalysis.ai/models/mistral-large-4) scores the preview 38 at $1.13 per task on the $1.36 / $4.18 list rates. Mistral says the reinforcement-learning run behind the preview is still going, so later results can differ. It plans to release the weights by the end of October and has not yet named their licence. Until then, treat Large 4 as a hosted API to evaluate, not as a model you can run yourself. ## MindsHub free tier The [MindsHub free tier](/pricing#free-tier) includes selected models at no charge. Currently included: the **MindsHub Air model** and **Jev**. No credit card is required; [fair use and daily rate limits apply](/fair-use-policy). ## Make the final choice on your own work Choose representative tasks and agree on what a usable result looks like. Check correctness, required input types, tool use, response time, and data-handling terms. Then divide the total spend, including failed attempts, by the number of results you would accept. Our [cost-per-task guide](/blog/llm-cost-per-task-vs-price-per-token) explains that calculation. The [model selection guide](/blog/which-llm-to-choose-12-key-aspects-to-consider-when-building-ai-solutions) covers the evaluation and hosting decisions. If you are changing the workspace as well as the model, use the [workspace migration checklist](/blog/manus-alternative-ai-workspace-migration#the-ai-workspace-migration-checklist) to preserve instructions, connections, and reusable work. --- *[MindsHub Agents](/download) provides a workspace with a choice of models and Anton, an open-source agent harness. [MindsHub Inference](/unified-inference) gives developers access to the MindsHub model catalog through one API. Check [model availability](/models) and [MindsHub pricing](/pricing) for the service you plan to use.* ### Your Work Should Outlive Any AI Agent URL: https://mindshub.ai/blog/manus-alternative-ai-workspace-migration — 2026-09-11 A practical Manus migration guide: restore affected work, preserve files and workflows, and compare model choice, skills, and access in MindsHub Agents. An AI workspace can hold months of useful work: reports, instructions, connected tools, and the corrections that make a recurring job run properly. Moving it takes more than downloading the last report. The Manus ownership transition made that dependency concrete. Some users had to back up and restore their data while the company separated from Meta. Manus has since resumed independent operations, but the question applies to any workspace: what can you keep using when the provider changes? ## What changed at Manus Meta acquired Manus in December 2025. In its [August 11 notice](https://manus.im/blog/a-note-to-our-users), Manus said its return to independence required deleting data generated by certain users on or after December 29, 2025. Affected accounts had a backup window, a temporary interruption, and a restoration process. Unaffected accounts did not need to act. On [September 1, Manus confirmed it had resumed independent operations](https://manus.im/blog/manus-resumes-independent-operations). That update says users who backed up their data can still restore it, with no restoration deadline. The August backup deadline has passed. A product's restoration archive and your own working copies serve different purposes. Keep standard-format copies of important outputs that open outside the original app. Test the files rather than assuming an export contains everything. ## Inventory the work around the agent A report may be easy to move. Reproducing it next month can require the original sources, saved instructions, permissions, and schedule. | What to preserve | Details to record | |---|---| | Outputs and history | Documents, code, datasets, original requests, corrections, decisions, and sources | | Project context | Brand rules, terminology, examples, preferences, and saved facts | | Skills and workflows | Prompts, templates, scripts, procedures, and quality checks | | Connections | Data sources, authorized accounts, access scopes, and the person who owns each connection | | Recurring work | Schedules, triggers, webhooks, notifications, and expected outputs | | Hosted services | Sites, applications, domains, databases, runtimes, and configuration; keep secrets in an appropriate vault | This inventory helps whether you stay with Manus, try MindsHub Agents, or operate your own tools. ## The AI workspace migration checklist 1. **Prioritize by business impact.** Identify the workflows people rely on and the historical work you cannot afford to lose. Start there. 2. **Export readable files.** Use Markdown or plain text for instructions, CSV or XLSX for data, DOCX or PDF for documents, PPTX for presentations, and source code plus configuration for apps. 3. **Write down how recurring work runs.** Capture the inputs, sources, tools, review steps, expected output, and common corrections. Include an example your team considers good. 4. **Map permissions.** Record what each connection can read or change. Reauthorize the replacement with the access it needs, and revoke obsolete access when the move is complete. 5. **Save reusable behavior.** Export skills, prompts, templates, and scripts in a form someone can inspect and edit. Check which parts depend on the original agent's tools. 6. **Account for hosting.** A downloaded website may still depend on a database, a domain, a secret, or a vendor's runtime. Record each dependency and who controls it. 7. **Rebuild one representative workflow.** Use the same inputs and acceptance criteria in the replacement. Reconnect the necessary services and verify the output. 8. **Compare several runs.** Record quality, time, cost, reliability, source traceability, and review effort. Use [cost per accepted result](/blog/llm-cost-per-task-vs-price-per-token) so retries count. 9. **Test another export.** Before moving more work, take an artifact, a skill, and its instructions back out of the replacement. Confirm they remain useful elsewhere. ## Compare Manus and MindsHub Agents on a real workflow Both products can connect tools, carry out multi-step work, and create files. The useful comparison is what your workflow requires and how much of its setup you can retain when something changes. | Workspace question | Manus | MindsHub Agents | |---|---|---| | **How is the agent chosen?** | Manus manages the agent experience and its underlying execution. | MindsHub Agents runs on an open-source agent harness, and you choose the model. | | **Can I change the model?** | Model and agent profiles operate within the managed Manus service. | You can choose among models in the MindsHub catalog and switch at any time. | | **Where can I use it?** | A managed cloud service with desktop features for approved local work. | In the browser or through desktop apps for macOS, Windows, and Linux. | | **How does it reach my data?** | Connectors, browser tools, and local-computer features provide access to external systems. | Connections to databases, files, and SaaS tools use credentials scoped to the connection. | | **What can I reuse?** | Projects, saved context, skills, and scheduled work. [Skills can be shared](https://help.manus.im/en/articles/14753565-how-to-share-and-use-skills-in-manus) as .skill files, ZIP archives, or GitHub repositories. | Projects, memory, skills, and artifacts remain in the workspace when the model changes. | | **What can I take away?** | Exported files and supported skill formats; restoration archives serve Manus's own recovery process. | Files and code produced by the agent, plus supported artifacts that can be published to a URL. Test export and hosting dependencies for each workflow. | Use [Manus's product documentation](https://manus.im/docs) to check the features your account needs. For MindsHub Agents, see the [download options](/download), [model catalog](/models), and [pricing](/pricing). A model mentioned in our [broader LLM comparison](/blog/navigating-the-llm-landscape-a-comparative-analysis-of-leading-large-language-models) is not necessarily available through MindsHub. An open-source agent harness makes the execution component inspectable. That alone does not prove that an entire hosted workspace, its credentials, or its schedules can move automatically. Verify each part of the inventory. ## Decide what is worth moving Staying with Manus can be the sensible choice when restored workflows work well and you prefer its managed experience. Test your exports and keep independent copies of important work even if you stay. MindsHub Agents is worth testing when explicit model choice and an open-source agent harness matter to you. Bring a recurring task, connect only the data it needs, and compare the output with the result you already trust. Our [model selection guide](/blog/which-llm-to-choose-12-key-aspects-to-consider-when-building-ai-solutions) helps separate model quality from problems in the prompt, context, or tools. Move more work after that test shows a practical benefit. Keep the instructions and evaluation criteria alongside the exported files so the next model or workspace can be judged against the same standard. [Try MindsHub Agents](/download) · [Return to the migration checklist](#the-ai-workspace-migration-checklist) ### How to Choose an LLM: Benchmarks, Cost, and Setup URL: https://mindshub.ai/blog/which-llm-to-choose-12-key-aspects-to-consider-when-building-ai-solutions — 2026-09-11 Choose an LLM using real tasks, relevant benchmarks, accepted-result cost, and hosting requirements. A practical guide to testing and replacing models. A model can look excellent in a demo and struggle with your first real document. Choosing it gets easier once you define what a useful answer must do. Start with a small set of jobs your team repeats: fixing a bug, extracting invoice fields, reviewing a contract, or answering a support question. Include the inputs and constraints that make those jobs difficult. The best candidate is the one that meets those requirements consistently at a cost you can sustain. Our [comparison of leading LLMs](/blog/navigating-the-llm-landscape-a-comparative-analysis-of-leading-large-language-models) covers current models, including DeepSeek V4.1 Flash, Qwen3.8-Flash-Next, GPT, Claude, Gemini, and Muse. Use it to choose candidates for the process below. ## Read the benchmark behind the score Composite scores are useful for narrowing a large field. The [Artificial Analysis Intelligence Index](https://artificialanalysis.ai/leaderboards/models) combines several evaluations; [Arena](https://arena.ai/) uses blind comparisons in which people choose between anonymous answers. These measure different things. A preferred writing style and a correct tool call are not interchangeable evidence. Check the index version and the tested configuration. Scores from different benchmark versions cannot be read as a model improving or declining. Reasoning effort, agent software, available tools, and fallback models can also change the result. Then look for tests close to your work: | Benchmark | What it tests | Where it helps | |---|---|---| | [MMLU-Pro](https://github.com/TIGER-AI-Lab/MMLU-Pro) | Multiple-choice knowledge and reasoning across 14 domains | A broad knowledge check | | [GPQA Diamond](https://github.com/idavidrein/gpqa) | Graduate-level science questions | Technical and scientific reasoning | | AIME and other competition-math tests | Multi-step mathematical problems | Quantitative reasoning | | [SWE-bench Verified](https://www.swebench.com/) | Resolving issues in real software repositories | Coding agents | | [LiveCodeBench](https://livecodebench.github.io/) | Coding problems collected over time | Coding performance with less exposure to old test questions | | [Terminal-Bench](https://www.tbench.ai/) | Completing tasks in a terminal environment | Agents that operate software | | [τ-bench](https://github.com/sierra-research/tau-bench) | Tool use in simulated user conversations | Service agents that must follow policies and complete actions | | [MMMU](https://mmmu-benchmark.github.io/) | Reasoning across text and images | Multimodal understanding | | [Humanity's Last Exam](https://lastexam.ai/) | Difficult expert questions across disciplines | Remaining gaps in broad reasoning and knowledge | Popular test questions may appear in training data. Labs may also optimize for a benchmark once it becomes commercially important. New questions help, but no public test reproduces your documents, users, and failure costs. Keep two or three candidates and test them against the same acceptance criteria. Our [guide to evaluations for AI solutions](/blog/best-practices-for-evaluations-evals-for-ai-solutions) covers how to organize that work. ## Check the constraints that can rule a model out ### Can it produce an acceptable result consistently? Score repeated runs where reliability matters. One excellent answer can hide a tendency to miss fields, invent citations, or choose the wrong tool. Record the failures as well as the average score. Test the reasoning setting you would deploy. A complicated analysis may benefit from more effort; a classification job may simply take longer. Public max-effort results do not tell you what the default setting will do. ### What does the whole job cost? Input, output, cache reads, and cache writes may have different rates. Reasoning tokens can be billable even when the user never sees them. Tool calls and repeated attempts add to the total, while batch or off-peak rates can reduce it if your workflow qualifies. The September 11 snapshot gives a useful example: Claude Sonnet 5's output rate is half GPT-5.6 Sol's, yet at max effort its benchmark task cost is $5.09 against $1.99. That measures benchmark attempts, not accepted work. Our [cost-per-task guide](/blog/llm-cost-per-task-vs-price-per-token) keeps the current figures and explains how to calculate spending per usable result. ### Will it finish in time? Measure the time until the user sees a useful answer and the time until the whole job is complete. Output speed alone misses time spent reasoning, waiting for tools, retrying calls, or reviewing the result. For a streaming chat, also record time to first answer token; a hidden reasoning token does not help the person waiting. ### Does it support the inputs and outputs you need? A long context window says how much a model can receive, not how reliably it will use every detail. Test retrieval from the beginning, middle, and end of your actual documents. Keep only the context the job needs. Check image, audio, video, and PDF handling separately. DeepSeek V4.1 Flash accepts text and images, while Gemini 3.8 Flash also accepts audio and video. A provider's file-upload feature may add its own processing behavior. For tools and structured output, test the interface as well as the prose: correct arguments, valid schemas, error handling, and recovery after a failed call. A model that explains the right action can still send the wrong tool request. ### Can you operate it under your requirements? Review where prompts are processed, retention and training terms, access controls, and the contracts your organization needs. Self-hosting changes who operates the system; it still requires those controls. Open weights make downloading possible, subject to the licence. They do not guarantee permission for every commercial use, support for fine-tuning, or a small hardware footprint. DeepSeek V4.1 Flash, for example, has an MIT licence but 552 billion backbone parameters, plus a 196-billion-parameter Engram memory component. [Its model card](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash) describes the serving requirements. Finally, check quotas, supported regions, SDKs, tool interfaces, and deprecation notices. Pin a specific version when the provider offers one. When an alias can move, track changes and rerun the evaluation. DeepSeek's [current V4 Flash API routing](https://api-docs.deepseek.com/quick_start/pricing/) is an example: older Flash model names now call V4.1 Flash. The requested name alone is not a version guarantee. ## Fix the source of a failure Look at the unsuccessful examples before buying more capability. - If the instructions are unclear, rewrite the prompt and add a worked example. - If the answer needs facts absent from the prompt, retrieve the relevant documents or query the source system. - If a recurring style or format requirement remains difficult, evaluate fine-tuning where the model supports it. Include training data and maintenance in the cost. Re-test after each change. Retrieval will not fix every reasoning failure, and a larger model cannot recover facts it was never given. ## Choose an API first unless hosting solves a specific problem An API is the practical default for most early evaluations. It lets you test models without procuring hardware or maintaining a serving system. You still need to account for external data processing, quotas, and usage-based billing. Self-hosting deserves a costed plan when data must stay in your environment, sustained volume can justify the hardware, or you need control a hosted API cannot provide. Include spare capacity, upgrades, monitoring, and the people who will operate it. For local trials, [Ollama](https://ollama.com/), [LM Studio](https://lmstudio.ai/), and [llama.cpp](https://github.com/ggml-org/llama.cpp) are common options. [vLLM](https://docs.vllm.ai/) and [SGLang](https://docs.sglang.ai/) serve models in production. Support varies by architecture and release, so confirm that the exact checkpoint works with the chosen runtime. Managed hosts such as Together AI, Fireworks AI, Groq, and Baseten offer another way to use open models without running the hardware yourself. ## Run a small decision process 1. **Write down the acceptance criteria.** Decide which errors are tolerable, how fast the job must finish, and where its data may go. 2. **Establish a baseline.** Run a capable model on representative tasks so you know whether the workflow is feasible. 3. **Test cheaper candidates and effort settings.** Count all attempts and compare [cost per accepted result](/blog/llm-cost-per-task-vs-price-per-token). 4. **Repair the recurring failures.** Improve the prompt, context, or tools according to what the failures show, then repeat the evaluation. 5. **Choose the operating setup and monitor it.** Record the model version and settings, test any fallback separately, and track quality, latency, and spend after release. ## Keep the evaluation when you replace the model Store prompts, test cases, scoring rules, and important workflow instructions where your team can inspect and move them. Those materials let you judge the next release without starting over. The [workspace migration guide](/blog/manus-alternative-ai-workspace-migration) covers the wider task of preserving memory, skills, connections, and artifacts. [MindsHub Inference](/unified-inference) provides one API for the models in MindsHub's catalog. It can reduce integration work, but switching models still needs an evaluation: supported parameters and behavior differ. Check the [model board](/models) and [MindsHub pricing](/pricing) when choosing what to test there. ## Frequently asked questions **What matters most when choosing an LLM?** Whether it passes your acceptance criteria consistently. Cost, latency, supported inputs, and hosting requirements determine whether that performance is usable. **Can I trust a leaderboard?** Use it to build a shortlist. Check the benchmark version, reasoning setting, tools, and fallback configuration, then test the candidates on your own work. **Should I self-host or use an API?** Start with an API unless data requirements, sustained volume, or operational control justify running the model yourself. **Do I need to fine-tune?** First identify the failure. Clearer instructions or better source material may solve it. Fine-tuning is worth testing for a repeated, measurable requirement when the model supports it and you have suitable data. **Which benchmarks matter for agents?** Look for tasks that use the tools your agent needs. SWE-bench examines repository issues, Terminal-Bench uses terminal tasks, and τ-bench tests tool use during simulated user interactions. **How do I keep up as models change?** Maintain the evaluation set, record versions and settings, and rerun it after a relevant release or provider change. Keep a tested fallback for the failures you need to recover from. --- *[MindsHub Agents](/download) provides a workspace with a choice of models and Anton, an open-source agent harness. [MindsHub Inference](/unified-inference) gives developers access to the MindsHub model catalog through one API. Check [model availability](/models) and [MindsHub pricing](/pricing) for the service you plan to use.* ### MindsDB is now MindsHub: same Minds, new shape URL: https://mindshub.ai/blog/mindsdb-is-now-mindshub — 2026-05-20 Updated: 2026-08-10 MindsDB is becoming MindsHub - a home for open-source AI agents. The story behind the rebrand, what's changing, and what stays exactly the same. Today, MindsDB becomes **MindsHub**. Same company. Same team. Same investors. Same open-source roots. What changes is the shape of the product - and the name finally says out loud what we've actually become: **a home for open-source AI agents.** > "Same Minds. New shape." > – Jorge Torres, Co-founder & CEO ![MindsDB is now MindsHub - same Minds, new shape](/blog/mindsdb-is-now-mindshub/00.webp) ## The short version If you only read one section, read this one: - **MindsHub is the new product surface. MindsDB is the parent identity.** The company, the people, and the mission are unchanged. - **Nothing breaks.** Your existing MindsDB workloads keep running. The open-source MindsDB engine and the Anton project continue. Every `mindsdb.com` URL redirects to `mindshub.ai`. No migration required. - **What's new** is a platform for running open agents in production - one-click deploy, model routing, pluggable memory, and a credentials vault - free to start. If that's all you needed, [try MindsHub](https://mindshub.ai). If you want the story behind the name, read on. ## Where this started: bring the AI to the data We started MindsDB in 2018, in Berkeley, California. Adam Carrigan and I had watched team after team try to put machine learning into production and grind to a halt on the same wall: the model lived in one place and the data lived in another. The standard pipeline of the era went like this. Extract the data from the system that owned it. Clean it somewhere else. Model it in a third place. Then thread the predictions back into the application that actually needed them. Every step was a copy, a handoff, and a thing to keep in sync. Most projects died in the plumbing long before they delivered a result. We took the inverse position: **don't ask the data to come to the AI - bring the AI to the data.** Put the model where the data already is - inside PostgreSQL, MySQL, MongoDB, Snowflake, the systems teams already trusted - and let people use the tool they already knew, SQL, to train and query it. No new cluster to learn, no fragile export job, no second copy of sensitive data to govern. The name came from the same idea. We were fans of Iain M. Banks' *Culture* novels, where the "Minds" are AIs that work alongside people - partners that augment human judgment rather than replace it. A "Mind" you could query like a database. **MindsDB.** That bet held up. What began as an open-source project grew into the most widely adopted open platform for AI analytics and data-workflow automation - built, from day one, for the people who already understand their data: SQL authors, data engineers, and analysts, not just ML specialists. ## How the work changed under our feet The mission never moved. The technology under it moved a great deal. - **2018–2022 - In-database ML.** Bring models to the data and train them with SQL. Forecasting, classification, anomaly detection - declared as queries, run where the data lived. - **2023–2024 - Beyond tables.** Large language models arrived, and "data" stopped meaning rows and columns. We extended the same connect-and-query idea to documents, vectors, and unstructured text: knowledge bases, semantic search, and RAG you could build with SQL instead of a stack of glue code. We re-architected the API layer around the [Model Context Protocol](/blog/mindsdb-now-supports-model-context-protocol-the-unified-ai-data-hub-your-enterprise-needs), turning MindsDB into a universal adapter between AI and any backend. - **2025–2026 - Agents.** The center of gravity shifted again, this time to agents that don't just answer but *act* - planning work, running code, calling tools, and following through. We [shipped Anton](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be), an open-source AI coworker for analytics, and watched a whole ecosystem of open agents take off around it. ![From in-database ML to a hub for open agents - the 2018 to 2026 evolution](/blog/mindsdb-is-now-mindshub/01.webp) By early 2026 the most valuable thing we did was no longer "machine learning inside a database." It was giving open agents a reliable place to connect to data, reach for tools, and run real work. The product had quietly become something its name no longer described. ## Why "DB" stopped fitting A name is a promise about what a product is. "DB" promised a database. That was the right promise in 2018, and it became the wrong one. People who met us through the name expected a database and were surprised to find an agent platform. People who needed an agent platform never looked, because the name told them we were a database. The label was working against the product. "Hub" tells the truth. A hub is where things connect: open agents on one side; your data, tools, and models on the other; and the operational layer in between that makes the connection actually run. That's what we are now. So that's what we're called. To be clear about what the rename is *not*: it isn't a new company, a change of ownership, or a pivot away from open source. Same company, same team, same investors. MindsDB is the parent identity; **MindsHub is the product.** ## What MindsHub is MindsHub is a home for open-source AI agents - the place to run them in production without standing up the infrastructure yourself. Open agents are powerful and, often, awkward to operate. Many are command-line tools that assume a developer's laptop. They need API keys wired up, data connected, memory persisted, and something watching them when they run long. MindsHub supplies that operational layer: - **One-click deploy** - go from repo to a running agent in seconds. - **A cloud runtime** - so agents keep working when your laptop is closed. Coming with the browser version. - **Model routing** - match the right LLM to each task, across Anthropic, OpenAI, Google, and open models, with no lock-in. - **Pluggable memory** - give agents persistent state instead of starting cold every session. - **A real UI** - a usable interface for agents that otherwise live only in the terminal. - **A credentials vault** - connect data and tools once; keep secrets encrypted and out of prompts. The agent lineup is open source and growing - **OpenClaw**, the generalist open agent; **Anton**, the open-source AI coworker for analytics; with **Hermes**, **NanoClaw**, and **OpenHuman** rolling out. It is **free to start** with no subscription and no minimum commitment, because "open" should also mean affordable to actually run. ![Inside MindsHub's managed infrastructure: the agents runtime (OpenClaw, NanoClaw, Anton, Hermes), a model router across providers, scratchpads, memories, a credentials vault, and data & tools access](/blog/mindsdb-is-now-mindshub/02.webp) ## What this means for you Whoever you are today, the change is designed to cost you nothing. | If you're a… | What changes | |---|---| | **MindsDB user with workloads in production** | Nothing. They keep running. No migration. | | **Open-source user of the engine** | The Minds query engine stays open and maintained at [github.com/mindsdb/engine](https://github.com/mindsdb/engine). | | **Visitor with old links or bookmarks** | Every `mindsdb.com` URL redirects to its `mindshub.ai` equivalent. | | **New to us** | Start at [mindshub.ai](https://mindshub.ai) - deploy an open agent and hand it real work. | The engine that started it all - semantic, federated queries across 200+ data sources - is still here. It's now one of the things agents stand on, rather than the whole story. ## Seven years in, by the numbers The shape changed because the work did. The foundation it changed *on* is real: - **500K+** deployments - **200+** data sources - **38K+** GitHub stars - **$50M+** raised, from Benchmark, Mayfield, Y Combinator, NVIDIA, and others ## Same Minds, new shape We set out in 2018 to democratize AI - to put real capability in the hands of the people who already understand their data, without making them become someone else. That hasn't changed and won't. What's changed is where that capability lives. In 2018 it was a model inside your database. In 2026 it's an open agent that can connect to your systems and do the work. The bet is the same one we made on day one: bring the AI to where the work already happens - and keep it open. Same Minds. New shape. Come see what we built - [try MindsHub](https://mindshub.ai), or read [how MindsHub relates to MindsDB](https://mindshub.ai/mindshub-vs-mindsdb). ### Use AI to do ML URL: https://mindshub.ai/blog/use-ai-to-do-ml — 2026-04-29 Vibe coding came for engineering. Vibe ML is coming for data work. Here's what it looks like when you ask an AI agent to train an XGBoost model - and it just… It's 5pm on a Tuesday. You've already had your last meeting, last coffee, and last shred of patience. Sarah from supply chain pings you on Slack: _Quick one - can you forecast our parts demand for the next six months? Just something rough. Need it for Friday._ Quick one. Friday. You know the drill. Pull purchase orders out of Postgres. Clean them into a weekly time series. Engineer some lag features. Train an XGBoost baseline. Validate it without lying to yourself. Build a dashboard somewhere Sarah can actually open. Write the email explaining what's solid and what isn't. It's a week, minimum, even if nothing breaks. And it's also, somehow, a "quick one." This is the tax on every analyst - the long tail of _hey-can-you_ requests that pile up faster than you can clear them. Forecasting is the worst of it, because it's not hard; it's just a lot of careful, repetitive work. Now imagine the same Slack ping, but your reply is _"give me a couple of minutes."_ That's what we're going to do. ![Sarah from supply chain wants a six-month demand forecast by Friday. You know what that actually means. Here's how Anton turned it into a two-minute job.](/blog/use-ai-to-do-ml/02.webp) ## **A quick word on what we're using** The agent in this post is called **Anton**. It's open source, runs locally on Mac, Linux, or Windows, and it's the kind of tool you'd describe to a colleague as "you talk to it like a person, and it actually does the work." You ask it something - connect to a database, look for trends, train a model, build a dashboard - and it goes off, plans the steps, writes Python and SQL, runs the code in its own sandbox, debugs itself when things break, and brings the result back. The code lives in a "scratchpad" you can inspect line by line, so nothing is hidden. That's the whole pitch. The rest is what happens when you actually use it. ## **Getting it on your machine** Anton ships as a desktop app (Windows, Mac) and a CLI (Linux, Mac, Windows). The install is a one-liner - instructions live on the [GitHub repo](https://github.com/mindsdb/anton). Five minutes, set it and forget it. I'm using the Windows desktop app for this, which is what you'll see in the screenshots. ## **Plugging in the data** First thing I do is point Anton at the data. There's an **Add Datasource** button down the left side of the app. I click it, pick Postgres, fill in the prompts. For this story I'm using a demo Supabase database with aerospace electronics purchase order data - F-35 sustainment program stuff. Real-shaped data, not toy data. Credentials never touch the LLM. Anton stores them in a local vault and only refers to them by name. ![Screenshot 1: Follow the connection flow - host, user, password, schema, and Anton confirms it's ready to query.](/blog/use-ai-to-do-ml/03.webp) _Screenshot 1: Follow the connection flow - host, user, password, schema, and Anton confirms it's ready to query._ ## **Looking around** Before forecasting anything, I want to know what's in there. So I just ask: _"Search for purchase orders tables in both sources."_ A few seconds later Anton comes back with what it found: a 500-row purchase orders table in the Supabase database. Part numbers, suppliers, lead times, quantities, defense program tags, quality flags - all the columns you'd expect. It even reads the room and suggests a next step: _"Want me to join this with the suppliers and line\_items tables?"_ ![Screenshot 2: Anton mapping out what's in the database before I write a single query.](/blog/use-ai-to-do-ml/04.webp) _Screenshot 2: Anton mapping out what's in the database before I write a single query._ This is the part that usually eats the morning. Schema spelunking, guessing what `qty_uom` means, asking the database team if `received_date` is in UTC. Done in one breath. ## **Trends before forecasts** You can't forecast a thing you don't understand. So I ask Anton for an overview dashboard - total spend, on-time delivery, top suppliers, country of origin, quarterly trends. A minute later it hands me an interactive HTML dashboard. $183.9M in total spend across the program. 84% on-time delivery. 96.6% quality acceptance. 57.2-day average lead time. Top 10 suppliers, ranked by spend with on-time overlay. A spend-by-country donut. The whole thing styled, dark mode, ready to drop in front of an exec. ![Screenshot 3: The overview dashboard Anton built in one prompt. $183.9M in spend, 84% on-time delivery - warm-up complete.](/blog/use-ai-to-do-ml/05.webp) _Screenshot 3: The overview dashboard Anton built in one prompt. $183.9M in spend, 84% on-time delivery - warm-up complete._ In a normal week, this is a Tableau session and an afternoon. Here it's the warm-up. ## **The actual ML part** Now the real ask: _"Please create an XGBoost model based on the purchase orders and create a forecast for demand."_ People are starting to call this kind of thing **vibe ML** - same energy as vibe coding, where you describe what you want and let the agent figure out how. It works for the same reason vibe coding works: the agent's job isn't to invent a new method, it's to be reliable at the well-known stuff. Forecasting purchase orders with gradient-boosted trees is well-known stuff. Anton can pick its own modeling library, but I nudge it toward XGBoost and scikit-learn anyway. Two reasons: it's faster (no time spent debating between five libraries), and the output is something a colleague can actually review later. What follows is the satisfying part. In the scratchpad, the steps tick off one by one: - Loads the PO data and explores it for forecasting - Builds a weekly time series - Engineers features - lags at 1, 2, 4 weeks; 3-month rolling averages; cyclical month encoding for seasonality - Trains two XGBoost regressors, one for order quantity and one for procurement spend - Generates a 6-month forecast with confidence intervals - Runs feature importance analysis - Builds an HTML dashboard for the result ![Screenshot 4: Each green checkmark is a step Anton ran and validated: load, engineer, train, forecast, dashboard. About two minutes total.](/blog/use-ai-to-do-ml/06.webp) _Screenshot 4: Each green checkmark is a step Anton ran and validated: load, engineer, train, forecast, dashboard. About two minutes total._ End to end, prompt to trained model to dashboard, it takes about two minutes. If I don't trust the result - and I shouldn't, blindly - I can ask Anton to dump the scratchpad. I get every cell of code, every output, every error it hit on the way. It's a Jupyter notebook by default, just one I didn't have to write. ## **Looking at the forecast** The output isn't a CSV with predictions buried in row 4. It's a dashboard. Actuals, fitted line, forecast, confidence band, MAPE printed on the chart so I don't have to ask. ![Screenshot 5: The actual forecast - actuals, fitted line, 6-month projection, confidence band, and MAPE on the chart. Ready to show Sarah.](/blog/use-ai-to-do-ml/07.webp) _Screenshot 5: The actual forecast - actuals, fitted line, 6-month projection, confidence band, and MAPE on the chart. Ready to show Sarah._ This is the part where vibe forecasting stops feeling like a gimmick. The output is something I'd be comfortable showing Sarah without rebuilding it from scratch in Tableau first. ## **Reading the model's report card** I always check the homework. _"Tell me more about the model."_ Anton pulls up the diagnostics. Two XGBoost regressors. Lag features at t-1, t-2, t-4 weeks. 3-month rolling averages. Cyclical month encoding. Holdout MAPE: 14.6% on quantity, 49.9% on spend. That spend MAPE looks rough - but Anton flags the reason itself: a $120 fastener and a $42K radar component live in the same column, so high-cost variance dominates the error. Useful caveat. Honest numbers. ![Screenshot 6: Anton's model diagnostics. Two XGBoost regressors, honest MAPE numbers, and the caveat already written in.](/blog/use-ai-to-do-ml/08.webp) _Screenshot 6: Anton's model diagnostics. Two XGBoost regressors, honest MAPE numbers, and the caveat already written in._ That's exactly the kind of asterisk I'd add to the email to Sarah myself. I just didn't have to. ## **Shipping it** Forecasts that live on my laptop don't help Sarah. So: _"Can you publish the forecasting dashboard, please?"_ A link comes back. ![Screenshot 7: "Here's your link." No deploy step, no subdomain request, no waiting.](/blog/use-ai-to-do-ml/09.webp) _Screenshot 7: "Here's your link." No deploy step, no subdomain request, no waiting._ Live dashboard from this run: [https://4nton.ai/view/90ccae06f/386c3121](https://4nton.ai/view/90ccae06f/386c3121) Anyone with the link can view it. No deploy, no Vercel, no waiting on platform engineering for a subdomain. I paste it to Sarah. It's 5:14pm. ## **What just happened** Connect, explore, trends, model, forecast, dashboard, share - the whole arc of an analytics request, in roughly the time it takes to make tea. This isn't a replacement for analysts. The good ones become more dangerous, not less. What collapses is the boring half of the day - schema spelunking, glue code, rebuilding the same dashboard for the third stakeholder this quarter, training a baseline model just so the team has a number to argue about. What's left is the part you got into the job for: knowing the business, framing the right question, pushing back when the data is lying. It's the same shift Claude Code did for engineers. The ones who use it well haven't lost their jobs - they ship more, own bigger surfaces, and don't write the same loop for the hundredth time. Anton is that, for data work. Vibe ML. Vibe analytics. Vibe forecasting - pick your flavor. Try it: [github.com/mindsdb/anton](https://github.com/mindsdb/anton). Or just type `anton` in your terminal and ask it something. ### MindsDB Product Updates: April 2026 URL: https://mindshub.ai/blog/mindsdb-product-updates-april-2026 — 2026-04-28 April brought major updates across MindsDB Anton and Query Engine, from shareable reports and explainable answers to broader integrations and stronger SQL… April was a busy month on both sides of the product. Anton picked up several upgrades that make analysis easier to share, audit, and continue across sessions. Underneath, MindsDB Query Engine v26.1 shipped with broader integration coverage, steadier SQL behavior, and Knowledge Base fixes. Here's what's new and why you might care. ## What's new in Anton ### `/publish` - share a report with one command Type `/publish` in Anton and your current report, analysis, or output goes live as an HTML page on `anton.mindsdb.com`. Run it again on the same work and Anton updates the existing page rather than creating a duplicate. `/unpublish` takes it back down. The point: analysis shouldn't stay trapped in a terminal. Now you can move from answer to shareable artifact without copy-pasting into a doc. ### Explainability - see how Anton got the answer Anton now records the trail behind each answer: which data sources it touched, the SQL it ran, the scratchpad steps it executed, and a plain-language summary of its reasoning. If a decision is going to ride on the result, you can inspect the work first. ### Stateful scratchpads - multi-step analysis that holds together Scratchpads now keep state across cells in a session. Variables, imports, and intermediate results carry forward, so Anton can build on previous steps the way an analyst naturally would - without re-running setup or repeating itself. ### `/memory` - full control over what Anton remembers Anton's memory is now inspectable and editable from the CLI: | Command | What it does | | --- | --- | | /memory rules | Behavioral rules Anton follows. View, edit, or delete entries. | | /memory lessons | Lessons Anton has picked up from past errors. | | /memory identity | Anton's understanding of who you are and how you work. | | /memory episodes | Full session history for reviewing prior work. | | /memory vacuum | Deduplicate and compact memory. | | /memory reset | Wipe a specific memory scope cleanly. | Three memory modes ship alongside the commands: - **Autopilot** - Anton decides what to remember. - **Co-pilot** - Anton checks with you on ambiguous saves. - **Off** - memory is disabled. The goal here is honest personalization. Anton can learn from past work, but you can always look at - and change - what it's learned. ### Smarter `/connect` - paste a connection string and go The data connection flow has been redesigned. Anton parses pasted connection strings, uses AI to fill in non-credential fields, saves credentials after a successful connection, and retries intelligently when something's wrong. Connecting a database now feels closer to a quick conversation than filling out a form. ## What's new in Query Engine v26.1 `v26.1.0rc1` shipped April 17 and `v26.1.0` followed on April 23. The release was about reliability, integration coverage, Knowledge Base behavior, and the kind of stability work that doesn't show up in screenshots but matters in production. ### SQL behavior, tightened Several SQL paths got steadier this release: expanded MySQL API test coverage, better MSSQL query result conversion, improved schema scoping for MySQL column discovery, and more reliable parsing of BigQuery select responses. These are small individually. They compound into more predictable agent behavior - fewer surprises when an LLM-generated query hits a real database. ### Broader integrations New or improved this month: HubSpot (including Leads), Raindrop.io, Denodo, Freshdesk, additional GitLab configuration, MotherDuck support inside DuckDB, Azure provider fixes, and clearer boot error messages for handlers. The throughline is reach. The more systems MindsDB connects to cleanly, the less custom glue code you write. ### Knowledge Base fixes Two notable fixes: Knowledge Base creation now works reliably when provider configurations aren't explicitly set in non-OpenAI scenarios, and integration lookup is now optimized by fetching directly from the database. If you're using Knowledge Bases to unify structured and unstructured data for retrieval, both of these should be felt as "things just work now." ### Stability, streaming, and docs Also in the release: improvements to error and crash handling, duplicate column handling, PID file creation, API handler filters, mixed search optimization, FAISS IVF behavior, and data-handler streaming. Documentation got refreshes across environment variables, Datastax, the GitLab handler, model-creation wording, and the home page. The unglamorous work that makes a platform actually nice to run. ## Try the April updates - **Anton** - for shareable, explainable analysis workflows - **Query Engine v26.1** - for the data layer underneath - [**Join the community**](/joincommunity) - for future updates and to send us feedback when something doesn't feel right ### A practical hands-on introduction to Anton URL: https://mindshub.ai/blog/a-practical-hands-on-introduction-to-anton — 2026-04-27 Learn how to install, configure, and use Anton - MindsDB’s open-source AI agent for conversational analytics that builds dashboards, runs SQL, and publishes… I'm really excited to be able to try MindsDB's new open-source agent for conversational analytics. It's different from everything I previously tried in a single crucial aspect: it makes me feel confident and free in choosing how to converse with it, a feeling that I only have when interacting with frontier agentic coding environments like Claude Code and Codex. Anton takes plain-English requests, pulls data, writes SQL and Python as needed to solve the data analytics task, executes this code, and returns things like tables, charts, explanations, and dashboards. When necessary to answer a user's question, Anton can create multi-step plans that gather partial datasets to then combine them at the end. It works with both public data and connected private data sources. In this tutorial, I will show you how to install, configure, and use Anton as a data analytics companion. Before we start the tutorial, let's first understand its main parts that make it a powerful and helpful AI assistant. ## Anton's main parts ![](/blog/a-practical-hands-on-introduction-to-anton/02.webp) Anton is structured as a brain-inspired loop: a chat session talks to the user and acts as an orchestrator that decides what to do, _scratchpads_ are the working memory where it actually does it, and a memory system records and recalls what it learned. Around that core sit a few infrastructure pieces: the LLM provider abstraction, the data vault, the datasource registry, and the publisher. At the end of this article, you'll find an appendix detailing each module along with its corresponding source file. As Anton is open-source, I encourage you to examine its codebase firsthand to understand how modern agentic CLI systems work under the hood. For now, here's a high-level overview of Anton's architecture. Anton is a command-line data assistant made of a few parts that work together in a loop. The **User** is the person driving everything from the terminal. They ask questions, request analysis, connect data, or ask Anton to publish results. The **CLI entrypoint** is the front door. It starts Anton, accepts the user’s input, and passes that input into the main conversation system. The **ChatSession** is the main coordinator. This is the orchestrator of the whole system. It keeps track of the conversation, decides what kind of help is needed next, and connects the user request to the right internal parts. It is responsible for moving the session forward: asking the model to reason, pulling in memory, using tools, and keeping track of the current datasource and scratchpad state. The **Scratchpad** is Anton’s working desk for computation. When Anton needs to actually do analysis work, this is where it happens. It is responsible for running Python-based tasks and keeping the working state of that analysis. It is triggered through the tool system and supports requests that need real execution, not just text generation (such as running a Python script, submitting a SQL query to a database management system, calling an API or web search). The **Isolated Python** environment is the runtime underneath the scratchpad. It is where code, packages, files, and scratchpad state actually live while work is being done. Its role is to give Anton a contained place to execute analysis safely and separately from the conversation layer. The **LLM client** is Anton’s reasoning layer. Its job is to turn the current conversation and context into a next step: explain something, ask for a tool, or decide how to approach a task. It works closely with ChatSession, which gives it the current context and then uses its response to keep the session moving. The **OpenAI provider** and **Anthropic provider** are the model backends behind the LLM client. They are the actual outside model services Anton can rely on. The LLM client chooses and talks to them, while the rest of Anton does not deal with them directly. The **Cortex memory coordinator** is Anton’s memory manager. Its purpose is to decide what past information matters right now and what new information should be remembered for later. It sits between ChatSession and Anton’s stored memory, helping Anton stay consistent across tasks instead of treating every request like a totally fresh start. The **Memory files** are where that memory lives. They hold saved notes, lessons, topics, and other useful context. Cortex reads from them and writes to them, while ChatSession benefits from that memory indirectly through Cortex. The **Tool registry + handlers** are Anton’s action system. This is the part that turns a model decision into real work. If Anton needs to run Python, access credentials, connect to data, or publish an artifact, this module dispatches the right tool. It acts as the bridge between “deciding” and “doing.” The **Vault + datasource tools** are responsible for data access and secret handling. Their logic is simple: Anton often needs credentials and datasource connections, but those should not be mixed into the model prompt. This module stores and injects the needed credentials only into the runtime and tools that require them. It interacts with the tool system above it and with the credential store below it. The **Local credential store** is where saved credentials live. It supports the vault layer by holding connection details that Anton can reuse. The user benefits from it because they do not need to re-enter everything each time, while the rest of Anton benefits because credentials can be supplied only where needed. The **Publisher** is Anton’s output-sharing module. Its role is to take generated artifacts, especially HTML-style outputs, and make them available as something the user can open or share. It is called through the tool system when the user asks for published output. The **Published artifacts** box represents the final hosted result of that publishing step. This is the user-facing destination for reports, dashboards, or other shareable outputs created by Anton. At a high level, the logic of Anton is this: the user asks for something in the CLI, the request enters through the CLI entrypoint, ChatSession coordinates the response, the LLM client helps decide what to do, Cortex provides memory, the tool system carries out actions, Scratchpad handles computation, the vault handles secure data access, and Publisher turns finished outputs into something shareable. All of these parts are separate so Anton can reason, remember, act, and publish without mixing those responsibilities together. Now that you understand Anton's high-level architecture, let's start with installation. > **Prefer a guided experience?** The [MindsHub Agents desktop app](https://mindshub.ai/agents) bundles Anton with zero terminal setup and is where new features land first. This tutorial follows the open-source CLI, aimed at developers who want to see how Anton works under the hood. ## 1\. Install Anton from the command line macOS / Linux ``` curl -sSf https://raw.githubusercontent.com/mindsdb/anton/main/install.sh | sh && export PATH="$HOME/.local/bin:$PATH" ``` Windows PowerShell ``` irm https://raw.githubusercontent.com/mindsdb/anton/main/install.ps1 | iex ``` ## 2\. Launch Anton Once installed, simply type the bellow command in the command line: ``` anton ``` If you want Anton to use a specific workspace directory, run it with the `--folder` parameter: ``` anton --folder /path/to/workspace ``` ## 3\. Connect Anton to a data source Anton accepts some built-in commands that don't require an LLM to understand. These commands are preceded with a forward slash and followed by the command name. You can see all supported built-in commands by typing `/help` and hitting `Enter`: ![](/blog/a-practical-hands-on-introduction-to-anton/03.webp)![](failed-asset-upload-placeholder) Since we are wanting to analyze some data, we need to point Anton to a source of data. For this, we will use the `/connect` command: ![](/blog/a-practical-hands-on-introduction-to-anton/04.webp)![](failed-asset-upload-placeholder) As you can see, Anton supports a variety of data sources. If the user asks for it during the conversation, Anton can also execute web search and get the web data. For this tutorial, I will connect to the data I have on Amazon Redshift: ![](/blog/a-practical-hands-on-introduction-to-anton/05.webp)![](failed-asset-upload-placeholder) Anton asked for the credentials and I provided then one by one. Now Anton is connected to a datasource. Let's ask it to describe it for us: ![](/blog/a-practical-hands-on-introduction-to-anton/06.webp)![](failed-asset-upload-placeholder) Oh, right, Anton needs an LLM to work and we didn't provide the credentials for any LLM. Let's use `/help` to see how to do that: ![](/blog/a-practical-hands-on-introduction-to-anton/07.webp)![](failed-asset-upload-placeholder) The command we need is `/llm`: ![](/blog/a-practical-hands-on-introduction-to-anton/08.webp)![](failed-asset-upload-placeholder) As you can see, the was Anthropic's Sonnet model already configured, but the key likely expired, so I changed the configuration to use Gemini instead and provided a working Gemini API key. Now, let's try our datasource description request again: ![](/blog/a-practical-hands-on-introduction-to-anton/09.webp)![](/blog/a-practical-hands-on-introduction-to-anton/10.webp)![](/blog/a-practical-hands-on-introduction-to-anton/11.webp) As you can see from this analysis, the datasource is a Redshift database containing a comprehensive lending dataset. It tracks the lifecycle of a loan from the initial applicant details through credit checks, application status, repayments, and potential collections. I'm not an expert in lending, so I will ask Anton to come up with three questions about the data that a financial data analyst would want to ask: ![](/blog/a-practical-hands-on-introduction-to-anton/12.webp) These seem to be interesting questions, so I will allow Anton answer the first one: ![](/blog/a-practical-hands-on-introduction-to-anton/13.webp) As you can see, Anton solved the task in three steps, each of which involved using the scratchpad to pull the data and make the necessary aggregations: - Calculate Cure Rate and Net Charge-Off metrics from database - Get total approved principal to calculate NCO rate. - Finalize portfolio total for NCO rate calculation. Now let's test Anton's built-in dashboard feature: ![](/blog/a-practical-hands-on-introduction-to-anton/14.webp) As you can see, I asked Anton to build a dashboard in plain English. I could add any detail I need, but I decided to let Anton decide what graphs to put on the dashboard. The dashboard was generated as an HTML file saved on my local hard drive. Anton supports the \`/publish\` command that allows sharing the dashboard with anyone online: ![](/blog/a-practical-hands-on-introduction-to-anton/15.webp) The [URL](https://4nton.ai/view/b85c1627d/f25cd272) is reachable by anyone with the link. If you click on it, you will see the dashboard generated by Anton: ![](/blog/a-practical-hands-on-introduction-to-anton/16.webp) You can ask Anton to modify the dashboard by providing additional details, and it will generate a new version that you can publish later. This concludes our introductory tutorial to Anton, a powerful open-source AI assistant for data analysts from [MindsDB](/). I encourage you to: 1\. Install Anton on your computer 2\. Connect it to a familiar dataset 3\. Challenge it with complex questions 4\. Observe how it uses the scratchpad to execute Python code and retrieve data to provide evidence-based answers ## Appendix: Anton Internals ##### Entry point and CLI - `anton/__main__.py`, `anton/cli.py` As we will see in the tutorial part below, to start the CLI, the user must execute the `anton` command in the command line. `anton`, in turn launches `python -m anton`, which calls `app()` in `cli.py`. `cli.py` is a Typer app that does dependency checks, bootstraps config, handles flags like `--folder`, runs setup wizards, and ultimately calls `run_chat(...)` in `chat.py`. It also wires in the slash-command handlers from `anton/commands/` (`/connect`, `/setup`, `/session`, etc.). ##### ChatSession - `anton/chat.py` `ChatSession` defined in `chat.py` is the central object that everything else hangs off of. For each conversation, a new `ChatSession` is created. It owns: - the message history with the LLM, - a reference to the active `LLMClient`, - a `ScratchpadManager`, - the `Cortex` (memory coordinator), - the workspace paths and settings. `ChatSession` has functions that stream tokens from the provider, intercepts tool-use events (coming from the LLM), dispatches them to actual tool executors (the actual Python code that implements the tool), and feeds the results back to the LLM. Slash commands (`/connect`, `/publish`, etc.) are handled inline as code rather than going through the LLM. ##### Tool layer - `anton/tools.py` This is the bridge between "the LLM emitted a tool call" and "actual Python ran." Tools are registered with the `@tool(...)` decorator into a registry; `build_tool_schemas` produces the JSON schemas sent to the model; `dispatch_tool` routes a tool name to its handler. `chat.py` doesn't know what tools exist; it just streams tool-use events and lets `tools.py` do the dispatch. ##### Scratchpad - `/scratchpad.py`, `/scratchpad_boot.py` This is Anton's "working memory". A `Scratchpad` is a long-lived **Python subprocess** running in its own virtual environment. `Cell` objects represent each code execution; the subprocess keeps state across cells similarly to how a Jupyter kernel works. `ScratchpadManager` handles lifecycle: creating, reusing, killing, and compacting scratchpads. `scratchpad_boot.py` is the script that actually runs _inside_ that subprocess - it sets up the environment, exposes the `progress()` marker used for inactivity heartbeats, and handles incoming cells over stdio. This is where the real work happens: API calls, pandas, scraping, file generation. ##### Memory system - `/memory/` This is the most elaborately structured part. The architecture mirrors brain regions: | File | Role | | --- | --- | | cortex.py | Executive coordinator. Owns two Hippocampus instances (one global and project-specific). Decides what to load into the LLM context. | | hippocampus.py | Storage engine - reads/writes markdown memory files (profile.md, rules.md, lessons.md, topics/*.md). | | episodes.py | Episodic memory. Logs every turn as JSONL in .anton/episodes/, one file per session. | | consolidator.py | "Sleep replay" - after a scratchpad session ends, replays it via a fast LLM call and extracts durable lessons into semantic memory. | ##### LLM abstraction - `/llm/` `provider.py` defines an abstract `LLMProvider` with `anthropic.py` and `openai.py` being concrete implementations. `client.py`'s `LLMClient` is the thin facade `ChatSession` actually talks to - it picks a provider based on settings and forwards requests. `prompts.py` holds the system prompt and dynamic prompt builders. ##### Data vault and datasources - `/data_vault.py`, `/datasource_registry.py`, `/commands/datasource.py`, `/config/datasources.md` The vault stores connection secrets. Secret values never go to the LLM - only the names do. When the LLM asks to use a datasource via the connect tool, `handle_connect_datasource` reads the credentials from the vault and injects them into the scratchpad subprocess's environment, where Python code can use them without the model ever seeing them. `datasource_registry.py` plus the catalog in `config/datasources.md` define which connectors exist and how to prompt for their credentials; the `/connect` slash command in `commands/datasource.py` drives the interactive setup. ### ##### Publisher and channels - `/publisher.py`, `/channel/` `publisher.py` packages an HTML artifact and POSTs it to the MindsDB-hosted "anton-services" endpoint, returning a public URL. This is what powers "open the dashboard in your browser." `channel/branding.py` and `channel/theme.py` style what gets published. ### How a single turn flows Putting it together, here's what happens when you type a message: 1. `cli.py` has already constructed a `ChatSession` and entered `_chat_loop`. 2. Your input is appended to history; `Cortex` injects relevant memory (profile, rules, recalled episodes) into the prompt. 3. `LLMClient` streams a response from the chosen provider. 4. As the model emits tool calls, `tools.dispatch_tool` runs them - most often `handle_scratchpad`, which sends a code cell to the `Scratchpad` subprocess; possibly `handle_connect_datasource` first to inject credentials. 5. Tool results stream back into the model, which iterates until done. 6. Every turn is logged to the episode JSONL by `episodes.py`. 7. When the session ends, `consolidator.py` replays it and may write new entries to `rules.md`/`lessons.md` so the next session is smarter. ### Introducing Anton: What Business Intelligence Is Supposed To Be URL: https://mindshub.ai/blog/introducing-anton-what-business-intelligence-is-supposed-to-be — 2026-03-30 Business intelligence wasn’t meant to slow down decisions. Anton changes that by delivering real-time, trusted, and auditable insights to anyone on your team… MindsDB is excited to introduce [MindsDB Anton](https://github.com/mindsdb/anton)\- a collaborative AI agent for conversational analytics and self-service BI, meant to fix business intelligence for good, built for teams that need answers now, not later. Download Anton via [Github](https://github.com/mindsdb/anton). First 1000 signups to use our Promo code "MDBCOMMUNITY100" to get one month free! Up until now, business intelligence has promised faster, smarter decisions. In reality, it’s slowed teams down. A question gets asked, added to a backlog, and answered days later - often too late to matter. By the time insights arrive, decisions have already been made, leaving teams relying on outdated data instead of real-time understanding. Anton solves this by closing the gap between questions and actionable insights. It turns natural language into instant, data-driven answers - analyzing live data, explaining results, and delivering decision-ready intelligence in seconds. With Anton, teams move from waiting on reports to acting on insights immediately, transforming analytics from a bottleneck into a competitive advantage. ## **What is MindsDB Anton?** Anton is an **autonomous business intelligence agent** that analyzes data like a human analyst, but operates at machine speed. You ask a question in plain language. Anton takes ownership of the entire analytical process: planning the analysis, writing and executing Python code and SQL to pull and aggregate information from your data sources, and delivering complete outputs including tables, charts, dashboards, and clear explanations. What makes Anton unique is that it doesn’t just generate answers. It produces **reproducible, auditable results**, showing exactly how each conclusion was reached. Every step is captured in a transparent reasoning scratchpad, giving teams full visibility into the logic behind their insights. This is not just another BI tool. It’s a system that **thinks, acts, learns, and self-improves.** Ask MindsDB Anton a question: “Show me the profit margins of NVIDIA” an “Build a dashboard” ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/03.webp) And it will also seamlessly generate a dashboard for you: ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/04.webp)![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/05.webp) Anton does not have a pre-built “profit margins analysis” skill. It does not ask which datasource to use. It figures it out. Anton pulls the latest financial data, writes the code to calculate the margins, and structures the results. Then it generates a dashboard with clear breakdowns and explanations- all in one flow. In one conversation. That’s the difference. Most tools give you the pieces. Anton gives you the answer. ## **How Will This Redefine Your Daily Workflow?**  Anton turns every question into instant, decision-ready insights. Finance teams detect cash flow anomalies in real time with full audit trails, sales leaders get clear pipeline insights without dashboard confusion, operations teams catch inefficiencies early, and marketing analyzes performance across channels in one place - no spreadsheets required. We built Anton to solve a problem that almost every organization faces: **the gap between asking a question and getting an answer that matters.** Anton brings speed, depth, and trust together in a single system. You and your team get answers instantly, understand how they were produced. Your organization can finally move away from delayed reporting to real-time, decision-ready intelligence. MindsDB’s internal team has already experienced how Anton improves their day-to-day tasks: - **Ron Zieglier, Sales Director,** turns everyday workflows into real-time analytics and insights- providing a better understanding of customer behavior, uncover trends, and act on live data instantly without manual effort. - **Sidney Rabsatt, Chief Product Officer**, turns raw product data into clear, continuous insights- helping track usage patterns, spot performance risks early, and connect signals across tools to understand what’s really happening. Instead of relying on dashboards, the outcome is a contextual view of product health and momentum that can be acted on. ## **From Question to Decision: How Anton Thinks, Plans, and Executes** When you ask Anton a question, it starts by loading context - who you are, how you work, and what it has learned before. It uses that to decide how to approach the problem, either applying an existing skill or creating a new path. From there, Anton opens a scratchpad and gets to work. It writes and runs code, pulls data, performs analysis, and adjusts if anything fails - all in one continuous flow. Once complete, it delivers a full answer with structured outputs, visualizations, and clear explanations. Then it learns. Anton captures what worked and improves for next time. A continuous loop: context, execution, learning - getting smarter with every question. #### **The Tool System: Extensible Reasoning** Anton comes with three built-in tools: - **scratchpad** - Run Python code with auto-install, persistent state, and built-in AI support - **memorize** - Save key learnings or preferences - **recall** - Retrieve past conversations when you explicitly ask for them Tools in Anton are simple to create and easy to use - you just define a function with clear inputs, and Anton handles the rest. Behind the scenes, it automatically validates inputs, runs the right tool, and returns results in real time, even streaming outputs for longer tasks like code execution. #### **Multi-LLM Support: Provider Abstraction** Anton works seamlessly with both Anthropic Claude (default) and OpenAI through a simple, unified setup. No matter which provider you choose, the experience stays the same - Anton automatically handles the configuration behind the scenes, so you can focus on getting insights without worrying about the underlying model or SDK. #### **Anton’s Local Vault** The Local Vault is Anton's secure credential store built into the workspace. When you connect a data source - like a PostgreSQL database, an API, or a cloud service - Anton saves the connection details (host, port, credentials, etc.) encrypted in the local vault under a named alias. These credentials  are then automatically injected as environment variables at runtime, so Anton can access them in scratchpad code without needing to paste passwords or connection strings manually. It's essentially a one-time setup: you register the connection once, and Anton can use it silently in every future session. Here’s how Anton gives you flexibility in how you access and manage models, whether you prefer full control or a managed setup: | Feature / Capability | BYOK Direct | MindsHub Inference (managed) | | --- | --- | --- | | Setup | Use your MindsDB API key or paste your own OpenAI / Anthropic key. | Sign up and get started instantly. | | Credential storage | Stored locally on your machine using Anton’s local vault. | Stored securely in the cloud - encrypted and never exposed. | | Model access | Access a single provider using your own key. | Access multiple models across different providers. | #### **The Execution Engine: Scratchpads** At the core of Anton is the scratchpad- an isolated, sandboxed Python environment that's the equivalent of having a second brain dedicated purely to computation. Here's how it works: When you give Anton a problem, it opens a scratchpad. That scratchpad is its own isolated virtual environment. It has its own Python runtime. It can install packages on demand. It can write code, run it, see the output, and adjust based on what it learns. The scratchpad works as a chain-of-thought engine, where each step is a cell of code(Let’s take the Nvidia profit margins example): 1. **Fetch data** – Pull the latest financial data for Nvidia. Anton figures out the right source and writes the code to retrieve it. 2. **Parse and transform** – Clean and structure the data into a usable format, like a pandas DataFrame. 3. **Calculate metrics** – Compute profit margins and related financial metrics directly from the data. 4. **Visualize** – Turn the results into a clear dashboard using charts and visualizations. 5. **Deliver** – Present the final answer and dashboard, ready to explore. The output is complete: structured data, visualizations, dashboards, and a clear written explanation of what the numbers show and why it matters. You don't get just an answer. You get something you can act on and defend. A seamless process where questions become **explainable, decision-ready insights in seconds**. ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/06.webp) ## ## **Getting Started with Anton: Turning Questions into Insights** Getting started with Anton is simple, yet powerful from the first question. Instead of building dashboards or writing queries, you just ask what you want to understand - Anton handles the analysis, execution, and delivers clear, decision-ready insights with explanations and visuals. In this section, we’ll walk through how to use the Open Source version of Anton in practice and how quickly it turns everyday questions into meaningful, decision-ready insights. > **The fastest way to try Anton is the MindsHub Agents desktop app**, where Anton is the open-source agent harness behind MindsHub Agents - [download it at mindshub.ai](https://mindshub.ai/agents). It comes with everything set up (no terminal or manual installation required) and it’s where new features land first. The steps below cover the open-source CLI version, best suited for developers who want to run Anton from the command line. **Pre-requisites** 1. Visit [Anton Github Repository](https://github.com/mindsdb/anton), and follow the instructions to install Anton where you will be able to provide your own Anthropic or OpenAI API Key or be directed to [MindsHub Inference](/unified-inference) to get a MindsHub API key. 2. Sign up for a [MindsHub Inference account to get an API key](/unified-inference). #### **Step 1: Set up an LLM Provider** You can make use of an Anthropic or OpenAI API Key. For this example we will be using a MindsHub API key. Sign up for [MindsHub Inference](/unified-inference) and get an API key. ### **Step 2: Accessing Anton** To access the [Open Source version of Anton,](https://github.com/mindsdb/anton) open a terminal window and run the following command: For MacOS/Linux: ``` curl -sSf https://raw.githubusercontent.com/mindsdb/anton/main/install.sh | sh && export PATH="$HOME/.local/bin:$PATH" ``` For Windows: ``` irm https://raw.githubusercontent.com/mindsdb/anton/main/install.ps1 | iex ``` Once it is installed, you will see the following: ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/07.webp) Now you can start Anton by running the command `anton`: ``` anton ``` > Once you have executed this, you will be prompted to review and accept Anton's policy. You can choose to read the policies by selecting y(yes) or n(no) and then select if you accept the Terms and Privacy Policy. Once you have made a selection, Anton's start up screen will appear. ### **Step 3: Provide Anton an API Key** Anton will prompt you to choose an LLM Provider, you can select between option 1 and 2. For this example we will make use of a Minds Cloud  API Key and select 1. ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/08.webp) If you have an API Key already, you can enter \`y\` and provide your API Key. You can execute \`/help’ to see all the commands available to you. ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/09.webp) ### **Adding a Datasource** You can connect to a datasource using the /connect command. You will be prompted to choose a datasource by the represented number or type the datasource name. As Postgres will be used in this example, the name or corresponding number, which is 9, can be entered: ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/10.webp) Anton will instruct which credentials/parameters it requires. It will prompt you one-by-one the host, port, database, user, password, schema and SSL(which you can opt to skip). Provide it with your database’s details: ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/11.webp) Anton will access any data you have previously connected and created. You can ask anton any question in natural language: ``` Analyze our supply chain performance over the last quarter- identify top bottlenecks in delivery times, highlight underperforming suppliers, and build a dashboard showing on-time delivery, inventory levels, and order fulfillment trends ``` ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/12.webp) Anton will automatically open a browser tab with the results of the dashboard, however it will also showcase the information in the terminal: ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/13.webp)![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/14.webp) Here is a look at the dashboard Anton created: ## **How Anton Learns and Remembers: A Brain-Inspired Memory System** Here's where Anton gets interesting. Anton doesn't start from scratch every session. It has a memory system inspired by how the brain works - and it's designed to be as human-readable as possible. Anton's brain has three key components: | The Hippocampus | The Cortex (Executive Control) | The Episodic Archive | | --- | --- | --- | | After Anton completes a scratchpad session, it records what happened. This is episodic memory - a searchable archive of every conversation, timestamped and indexed. When you ask Anton "What did we work on last time?", it uses the recall tool to search through past sessions and find relevant context.But episodic memory is raw. It's the full transcript. That's useful for questions like "How did we fix that bug three weeks ago?" But it's not how you actually learn from experience. | This is where Anton's real learning happens. After a scratchpad session ends, Anton replays what it did - in compressed form - and asks itself: What should I remember from this?This process is called consolidation. It's inspired by sleep in the brain: humans consolidate memories while they sleep, converting raw experiences into structured knowledge. Anton does this offline, after each session, extracting reusable lessons. | Every conversation is logged in JSONL format in .anton/episodes/. One file per session. Timestamped, searchable, never forgotten. You can grep through it yourself if you want.Memory operates at two scopes: global (across all your projects) and project-specific (within a single workspace). Your identity and global lessons are shared everywhere. Project-specific rules and domain expertise live locally. | ## **How Anton Monitors and Consolidates: The Schedule** Here's the system that ties it together: After each session, Anton runs a consolidation pass. This isn't just logging. It's active learning: 1. **Replay** - Take the scratchpad trace and compress it. What actually happened? 2. **Extract lessons** -  What should be remembered? If Anton ran into an error and fixed it, that's a lesson. If Anton discovered a new API endpoint or rate limit, that's a lesson. If Anton found a more efficient way to do something, that's a lesson. 3. **Persist** \- Write these lessons to `rules.md`, `lessons.md`, or topic-specific markdown files. 4. **Index** - Make the memories searchable via embedding, so when Anton encounters a similar problem next time, it can find them. This is self-evolution. Anton doesn't just solve your problem and forget about it. Every problem teaches it something. Every error is an opportunity to encode a rule. Every success is an opportunity to abstract a lesson. Over time, Anton becomes _your_ Anton. It learns your preferences. It learns your codebase conventions. It learns which APIs work and which are slow. It learns your domain expertise. ## **How Anton Builds Skills and Adapts.** Anton has a skill library. These aren't pre-baked plugins. They're learned patterns. When Anton encounters a new problem type, it builds a solution from scratch in the scratchpad. If it's similar to something it's done before, it retrieves memories and adapts them. If it's novel, it figures it out and learns from the process. Over time, commonly used patterns become _templates_ - quick scratchpad setups that Anton can deploy when it recognizes a similar problem. Want to fetch and analyze stock prices? Anton learns the pattern. Next time you ask, it's faster. Next time after that, even faster. But these aren't rigid. They adapt. If Anton discovers a better API, it updates its knowledge. If a rate limit changes, it learns the new constraint. If you teach it a preference, it remembers. This is different from traditional AI agents that come with a fixed skill set. Anton's skills _emerge_ from doing work. They're organic. They improve. ## **Use Cases: Where Anton Delivers Value** Anton is designed to solve real business problems where speed, clarity, and depth of insight matter. Instead of relying on manual analysis or pre-built dashboards, teams can ask questions and immediately understand what’s happening and why. Here are some of the key ways Anton is used across organizations: - **Executive reporting and decision-making:** Leaders often rely on static dashboards that lack context. Anton enables instant drill-downs into metrics like revenue or growth, explaining what changed and why, so decisions can be made with confidence. - **Revenue and RevOps analysis:** Pipeline gaps, deal risk, and conversion issues are often hidden across systems. Anton connects the dots, identifying at-risk deals, stalled stages, and revenue drivers in real time. - **Financial analysis and forecasting:** Finance teams need accurate, explainable insights. Anton provides breakdowns of financial performance and can build predictive models to forecast revenue, expenses, or risk. - **Operational and supply chain insights:** Operational data is often distributed and difficult to analyze quickly. Anton identifies inefficiencies, delays, or anomalies, helping teams respond before issues escalate. - **Embedded analytics for applications:** For teams building products, Anton can generate ready-to-share dashboards and visual outputs, making it easy to embed analytics directly into user experiences. Across all of these use cases, the common thread is simple: Anton removes the friction between asking a question and getting a **clear, explainable answer**, allowing teams to move faster and make better decisions. ![](/blog/introducing-anton-what-business-intelligence-is-supposed-to-be/15.webp) ### Turning Claude Code into a Conversational Data Analyst with the Minds Plugin URL: https://mindshub.ai/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin — 2026-03-11 Build conversational analytics with the Minds Plugin for Claude Code and connect Claude to Postgres, Snowflake, and BigQuery using natural language queries. AI assistants like Claude are becoming powerful collaborators for developers and data teams. They can generate code, summarize documents, and help reason through complex problems. But there is still a major limitation. Most AI assistants operate **without direct access to your company’s data**. They generate responses based only on prompts and training data. When questions involve real metrics, revenue numbers, or operational insights, the model cannot verify answers against the systems where the truth actually lives. The **Minds Plugin for Claude code** solves this problem. By connecting Claude to Minds, MindsDB’s conversational analytics product, Claude can ask questions about live data and receive grounded answers generated from structured SQL queries. Instead of guessing, Claude becomes a **data-aware conversational analyst**. ## **What Is Minds?** Minds is designed to behave like a thoughtful data analyst you can talk to. You ask questions in natural language, and Minds translates them into structured SQL queries against your databases. It retrieves the relevant data, analyzes it, and returns clear results. Think of it as a teammate who understands: - Business metrics - Time-based analysis - Filtering and aggregation - Comparisons across categories For example, instead of writing SQL manually, you might ask: - “What was the total revenue for Product A in Q2 2024?” - “How many new customers joined in EMEA during January 2025?” - “Which product had the highest profit margin in Q3 2024?” Behind the scenes, Minds converts these questions into queries, executes them against the data, and returns the result. The goal is simple: turn natural language into precise, traceable analytics. ### **Why Use Minds Plugin Instead of Another MCP Server?** While MCP servers allow AI assistants to connect to external tools, most MCP implementations expose **only a single service or data source**. This often leads developers to build multiple connectors for different databases, APIs, or analytics systems. Minds simplify this architecture. Instead of creating separate MCP integrations for every system, Minds acts as a **unified data intelligence layer** that Claude can query through a single MCP server. This offers several key benefits: #### **1.One Server, Multiple Data Sources** Instead of creating separate MCP servers for each database, Minds connects to multiple systems like Postgres, Snowflake, and BigQuery. Claude can query all of them through a single plugin. #### **2.Cross-System Analysis** Because Minds sits above your data sources, Claude can analyze information across systems without developers writing custom orchestration logic. #### **3.Centralized Data Access** Minds translates natural language questions into SQL and routes them to the appropriate data source, enabling analysis across systems without exposing their complexity. #### **4.User Management and Authentication** Minds provides built-in authentication and permission controls so organizations can manage access to data securely. #### **5.Conversation-Based Data Exploration** Most MCP tools execute one operation at a time. With Minds, users can ask follow-up questions and refine analysis step by step while maintaining context. #### **6.Built-in Natural Language to SQL** Minds automatically translates natural language questions into SQL queries. You don’t need to build custom query-generation logic inside your MCP server. #### **7.Less Custom Infrastructure** Without Minds, teams often build multiple MCP connectors, query generation logic, and access control layers. The Minds plugin consolidates these capabilities into a single integration. #### **8.Governance and Query Transparency** Minds generates structured SQL queries, which makes insights traceable and auditable. Organizations can maintain visibility into how results are produced. By combining Claude’s reasoning capabilities with Minds’ data access layer, teams can build **AI workflows that analyze real business data without creating dozens of custom integrations.** ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/02.webp) ## **What the Minds Plugin Enables** The **Minds Plugin** connects Claude directly to a running **Minds** instance, allowing Claude to ask questions about your organization’s data and retrieve answers grounded in real records. Instead of relying only on prompts or training data, Claude can analyze live information through Minds. This enables workflows such as: - **Analyzing revenue trends** across products, regions, or time periods - **Investigating product performance** and growth patterns - **Exploring customer behavior** and segmentation - **Breaking down metrics** by geography, timeframe, or category Because Minds translates natural language questions into structured SQL queries, Claude can reason over actual database results rather than generating hypothetical responses. The result is a much more powerful workflow: Claude becomes a **conversational interface for analytics**, capable of exploring business data step-by-step like a thoughtful analyst. You can connect to various databases: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/03.webp) ### **How the Minds Plugin for Claude Works** Under the hood, the plugin connects Claude to Minds through the **Model Context Protocol (MCP)**. This architecture allows Claude to call external tools that execute queries against your data. Here’s what happens step by step: 1. **Claude receives a question:** A user asks Claude a question about business data. 2. **Claude calls a Minds tool:** Through MCP, Claude can access a set of tools exposed by the plugin. 3. **The MCP server forwards the request:** A lightweight Node.js MCP server sends the request to the Minds API. 4. **Minds executes the query:** Minds translates the request into SQL and runs it against connected data sources such as Postgres, Snowflake, or BigQuery. 5. **Results return to Claude:** Claude receives the structured results and can explain, summarize, or continue the analysis. Importantly, the MCP server acts only as a **thin REST wrapper**. It does not store state or cache data. Every request goes directly through Minds to your underlying databases, ensuring responses reflect the latest information available. The flow looks like this: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/04.webp) ### **Project Structure** The Minds Plugin is designed to stay lightweight and easy to extend. Its structure reflects the simple architecture behind the integration: **MCP Server** - Built with Node.js - Exposes the tools Claude can use - Routes requests to the Minds API **Tool Definitions** - Each tool corresponds to a Minds API endpoint - Enables operations such as querying data or retrieving insights **Authentication** - Uses a **Bearer token** to authenticate with the Minds API **External Data Layer** - Minds connects to your databases and data warehouses - Examples include Postgres, Snowflake, BigQuery, and other supported sources Because the server does not maintain internal state, the system stays fast, predictable, and easy to operate. ``` ├── .claude-plugin/ │ └── marketplace.json # Marketplace catalog └── plugins/ └── minds/ ├── .claude-plugin/ │ └── plugin.json # Plugin manifest ├── .mcp.json # MCP server config ├── package.json ├── src/ │ └── index.mjs # MCP server - 19 tools, pure fetch ├── skills/ │ └── minds-data/ │ └── SKILL.md # Auto-invoked skill for data workflows └── commands/ ├── connect.md # /minds:connect ├── ask.md # /minds:ask └── explore.md # /minds:explore ``` ## **Quickstart: Getting Started with the Minds Plugin in Claude Code** In this quickstart, we’ll connect Claude to **Minds** using the Minds Plugin. Once configured, Claude will be able to send natural language questions to Minds, which translates them into SQL queries and retrieves results directly from your databases. Within minutes, you’ll be able to explore your data conversationally. In this tutorial, we will show how easy it is to setup this with Visual Studio code and the Claude Code VS Extension. Pre-requisites:  1. Clone the [Minds plugin for Claude Code repository](https://github.com/mindsdb/claude-plugin?tab=readme-ov-file#) and open in Visual studio. 2. Install the Claude code extension in Visual Studio and sign in with your Claude account. 3. Ensure Node (Node.js 18<) dependency is installed on your device. This installs the packages needed to run the MCP server. **Step 1: Get Minds API Key** You login to your [MindsHub Inference](/unified-inference) profile and navigate to the API Keys tab to obtain an API key. **Step 2: Set your environment variable:** ``` export MINDS_API_KEY=your_key_here ``` A great tip is that you can actually provide Claude code your Minds API key and advise it to set it up in your environment and it will do the work for you. This will create an env. file in the src folder: ``` MINDSDB_API_KEY=mdb_mxet9C9g.yS8BiOBzbXcjUlfsGSspXOtHHIFYFYF MINDS_BASE_URL=https://mdb.ai ``` **Step 3: Install the plugin:** Let’s add the market place to Claud code. In Claude Code, open a chat and run: ``` /plugin marketplace add mindsdb/claude-plugin ``` This tells Claude about the Minds plugin marketplace hosted at mindsdb/claude-plugin. If you are working on a project and want this marketplace auto-discovered for everyone, add .claude/settings.json to your repository. Once done, you will receive this message:  ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/05.webp) Now you can install the Minds Plugin from the Marketplace. Still in Claude Code, run: ``` /plugin install minds@minds-marketplace ``` This installs the Minds plugin from the new marketplace. After it succeeds, Claude will have access to the Minds MCP server and its tools (datasources, minds, queries, catalog, etc., as documented in the README). ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/06.webp) ## **Connect Your Data and Create Your Mind** Now that the plugin is installed and connected, the next step is to **create a Mind and start interacting with it from Claude Code**. A Mind acts as your conversational analyst, translating natural language questions into SQL queries that retrieve insights from your connected data sources. Once created, you can begin asking questions directly in Claude Code and explore your data step by step through conversation. In Claude Code extension, prompt it to connect to your database: ``` Connect to my postgres database using these credentials: "user": "demo_user”, "password": "demo_password”, "host": "samples.mindsdb.com", "port": "5432”, "database": "demo”, "schema": "sample_data ``` It will ask you to allow this command, select yes: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/07.webp) If you are connected to this datasource already, Claude will advise the following:  ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/08.webp) If you select yes, it will give you the following results: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/09.webp) If you are connecting a database for the first time, which you have not connected to Minds yet, you will get the following results. Here we connect with another database): ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/10.webp) You can list all the data sources connected in Minds: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/11.webp) Now you can create a Mind. Create a finance analyst agent that will help you query financial data in the demo\_postgres database. ```sql Create a Mind called "financial_analyst" that can answer questions about financial data for our investment company using the financial_portfolio table in the demo_postgres database ``` You will get prompted the below where you have to select ‘Yes’. You will see that a system prompt has been generated to instruct the Mind.  ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/12.webp) Result: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/13.webp) You can verify that the status of the Mind is ready for questions: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/14.webp) ## **Ask Your First Question in Claude Code** Let’s ask a couple of questions in Claude Code. **Question 1:** What stocks are in the portfolio? ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/15.webp) **Question 2:** What's the percentage breakdown of investments by category in the portfolio? ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/16.webp) **Question 3:** What category has the most exposure? ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/17.webp) **Question 4:** Leadership has mandated that we limit our exposure to crypto to 10%. Is the portfolio compliant and if not, what must I do to make it compliant? ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/18.webp) The Minds Claude Code Plugin allows you to Update or Delete a Mind: ![](/blog/turning-claude-code-into-a-conversational-data-analyst-with-the-minds-plugin/19.webp) ### **Why the Minds Plugin for Claude Code Matters** The **Minds Plugin** changes what AI assistants can realistically do with data. Most AI tools today are excellent at generating text, writing code, or summarizing documents. But when it comes to **business analytics or operational data**, they still operate at a distance from the systems where that data actually lives. This creates a gap. You can ask an AI assistant questions about strategy, revenue, or customer behavior, but without direct access to your databases, the answers remain speculative. The model might reason well, but it cannot verify anything against real records. The Minds Plugin closes this gap by connecting Claude directly to **Minds**, which translates natural language questions into SQL queries and retrieves results from your databases. Instead of guessing, the Minds Plugin for Claude code can **analyze real data**. ## **The Missing Link Between AI and Data** Conventional analytics workflows are complex and slow. Data is typically exported from operational systems, transformed through ETL pipelines, stored in warehouses, and then visualized in dashboards before teams can ask questions. While powerful, this process introduces delays, stale data, and friction when new questions arise. The **Minds Plugin for Claude Code** simplifies this workflow. Instead of building dashboards or writing SQL manually, users can ask a question in natural language. Minds translates that question into SQL, runs it directly against the connected data source, and Claude explains the results. This turns analytics into a conversational process rather than a reporting exercise. This approach also closes an important gap in the AI ecosystem. Most language models are strong reasoning engines but lack direct access to enterprise data systems like databases, warehouses, and internal business metrics. By connecting Claude to Minds, AI assistants can analyze real data in real time rather than generating speculative responses. At the same time, it addresses a broader market challenge. Many organizations struggle with the complexity of traditional analytics stacks, while conversational AI tools often remain disconnected from the underlying data. The Minds Plugin bridges these worlds by allowing AI assistants to query business data directly through natural language, enabling faster insights while maintaining accuracy, traceability, and control. ### **What Does This Means for Users?** For users, this fundamentally changes how they interact with their data. Instead of switching between tools like dashboards, SQL editors, spreadsheets, and AI assistants, users can explore insights through conversation. They can: - Ask questions about business metrics in natural language - Retrieve results grounded in live databases - Refine analysis through follow-up questions - Investigate trends without writing SQL This creates a workflow that feels less like querying a database and more like **working with a data analyst who understands your systems**. For developers and data teams, this also removes friction. They can build applications where AI assistants can reason over operational data without exporting it into separate analytics pipelines. ### **Conclusion: A New Way to Work With Data** The combination of Claude and Minds represents a shift in how analytics can be performed. Instead of building reports first and asking questions later, users can start with the question and let the system retrieve the relevant data. AI assistants become more than productivity tools. They become **analytical partners capable of reasoning over real business data**. And when natural language becomes a reliable interface for analytics, the way organizations interact with their data begins to change. Check out the [Minds Plugin for Claude Code Repository](https://github.com/mindsdb/claude-plugin?tab=readme-ov-file#) and [contact our team to find out more.](../book-demo) ### Introducing MindsDB v26.0.0 With Improved Agents and Knowledge Bases URL: https://mindshub.ai/blog/introducing-mindsdb-v2600-with-improved-agents-and-knowledge-bases — 2026-02-26 Introducing MindsDB v26.0.0 - faster Knowledge Bases, smarter Agents, stronger integrations, and production-ready performance. ## **A Federated Data & Context Engine for AI Apps and Agents** Building AI applications and agents is no longer just about choosing the right model. The hard part is connecting that model to real, messy, distributed data safely, observably, and in a way that actually fits into production systems. With **MindsDB** [**v26.0.0**](https://github.com/mindsdb/mindsdb/releases/tag/v26.0.0), we’re doubling down on a clear direction: **MindsDB is the federated query and context engine for AI applications and agents.** This release sharpens MindsDB around the core primitives that matter most to AI app developers: - unified access to data across systems - reliable agents that work directly on that data - and structured, actionable outputs you can analyze or write back v26.0.0 is a foundational step toward MindsDB acting as a universal Model Context Protocol (MCP) server, a single point where AI systems read from and write to enterprise data with confidence. ## **Why This Matters If You’re Building AI Apps or Agents** Most AI stacks today still look like this: - pull data from multiple systems with custom pipelines - ship rows into an LLM or agent framework - post-process unstructured output - push results back through another integration It’s slow, brittle, and hard to trust. MindsDB [v26.0.0](https://github.com/mindsdb/mindsdb/releases/tag/v26.0.0) moves this workflow _into the data plane_: - Query data where it lives - Pass it to agents for semantic reasoning - Analyze the results using SQL - Optionally write results back That’s the workflow MCP is trying to standardize. MindsDB is making it practical. ## **What’s New in v26.0.0** This release focuses on three themes that directly improve how developers build AI-powered systems. #### **1\. More Officially Supported Data Integrations** We’ve expanded the set of **verified and supported integrations**, so you can connect data across your stack without building bespoke connectors. **New database integrations include:** - Oracle - Databricks - Amazon Redshift - TimescaleDB - MariaDB **New application integrations include:** - **HubSpot** (CRM, tickets, activities, timeline events) - **Shopify** (products, orders, customers, inventory, marketing events) - **NetSuite** (SQL access via SuiteQL) You can query all of these sources using simple SQL, then feed the results directly into AI agents. ![](/blog/introducing-mindsdb-v26.0.0-with-improved-agents-and-knowledge-bases/03.webp) #### #### **2\. Faster, More Reliable Agents (Without Changing How You Use Them)** Agents in v26.0.0 are now built on a [Pydantic AI](https://pydantic.dev/case-studies/mindsdb) agentic framework, replacing LangChain. What this means for you: - Better performance and reliability - More predictable behavior - Fewer hidden abstractions What doesn’t change: - Agents are still created with CREATE AGENT - Existing agent workflows continue to work - No rewrite required to benefit from the new foundation This is a purely structural upgrade that makes agents dependable enough to sit in the critical path of AI applications. #### **3\. Structured, Actionable Agent Outputs - via SQL** One of the most important shifts in v26.0.0 is how agents return results. Instead of treating agent responses as unstructured text, you can now shape outputs using SQL itself. **Example: semantic enrichment + analytics** ```sql SELECT product_category, average_sentiment FROM amazon_reviews_agent WHERE question = 'What is the sentiment for each product category?'; ``` In this pattern: 1. You query structured data (e.g. reviews, transactions, tickets) 2. Each row is passed to an agent for semantic reasoning (e.g. sentiment, classification, extraction) 3. The agent is guided to return structured columns 4. You can immediately: - aggregate results - join them with other tables - or write them back to a database This turns LLM output into database-ready data, not just text blobs. With this structured output, users can also immediately build dashboards and charts, leveraging a new feature in the MindsDB GUI for simple chart creation. We think of this as semantic decoration: enriching rows with AI-generated meaning, then continuing to work with them using SQL. ![](/blog/introducing-mindsdb-v26.0.0-with-improved-agents-and-knowledge-bases/04.webp) ## ## **Backward-Incompatible Changes (Read Before Upgrading)** For those relying on the features deprecated below (e.g. LangChain, ChromaDB, built-in ML handlers), MindsDB v25.14.x remains the recommended option. #### **Agents** - LangChain has been fully deprecated - Agents now run on a Pydantic-based framework - Agent creation and usage syntax remains the same #### **Knowledge Bases (KBs)** - ChromaDB has been deprecated - PGVector is now the default vector store for Docker Desktop - MindsDB via PyPI or Docker image do not have any default vector store These changes significantly improve KB performance for large-scale ingestion and retrieval. #### **ML Handlers** - Built-in ML integrations (e.g. Lightwood) have been removed - MindsDB now focuses on: - federated data access - knowledge bases - AI agents If you need custom ML logic, you can still bring your own model (BYOM) and integrate it into agent workflows. ![](/blog/introducing-mindsdb-v26.0.0-with-improved-agents-and-knowledge-bases/05.webp) ### MindsDB Product Updates - February 2026 URL: https://mindshub.ai/blog/mindsdb-product-updates-february-2026 — 2026-02-25 Stronger Knowledge Bases, improved integrations, enhanced SQL reliability, GUI performance boosts, and critical security upgrades across MindsDB. February brings a focused set of improvements across performance, stability, security, and usability in MindsDB. This product update explores strengthening the foundation of Knowledge Bases, expands and refines integrations, improves SQL reliability, enhances GUI performance, and continues our commitment to security and maintainability. MindsDB has officially released [**v26.0.0**](https://github.com/mindsdb/mindsdb/releases/tag/v26.0.0), marking a major platform upgrade that brings broad improvements to SQL robustness, integrations, knowledge base behavior, bug fixes, documentation clarity, and security hardening - all designed to boost reliability, performance, and user confidence in production workloads. The release of [v26.0.0](https://github.com/mindsdb/mindsdb/releases/tag/v26.0.0) delivers more predictable query behavior, smoother developer workflows, expanded cloud reach, and a cleaner, more secure codebase, making it an exciting step forward for teams building real-world AI and analytics solutions ## **Knowledge Bases** Docker Compose deployments now default to [**PGVector**](https://docs.mindsdb.com/integrations/vector-db-integrations/pgvector) as the [Knowledge Base](https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/overview) store, providing a more consistent and production-ready vector backend out of the box, with improved reliability for semantic search workloads. We also fixed an issue where mixed-case column names did not display correctly, ensuring schemas are reflected exactly as defined and reducing confusion when working with structured metadata. A bug that could cause duplicate [Knowledge Base](https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/overview) IDs on a second insert has been resolved, along with related [PGVector](https://docs.mindsdb.com/integrations/vector-db-integrations/pgvector) handling improvements, increasing data integrity and preventing unexpected conflicts.  Finally, inserts into [Knowledge Bases](https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/overview) are now batched by default, significantly improving ingestion performance and making it faster and more efficient to load large datasets. Together, these updates make [Knowledge Bases](https://docs.mindsdb.com/mindsdb_sql/knowledge_bases/overview) more robust, predictable, and scalable for real-world AI applications. ![](/blog/mindsdb-product-updates-february-2026/02.webp) ## **Integrations** Integration READMEs are now pulled statically from GitHub instead of being locally served, ensuring documentation stays up to date with the latest changes and reducing inconsistencies between releases. We enhanced the [Shopify](https://docs.mindsdb.com/integrations/app-integrations/shopify#shopify), [Confluence](https://docs.mindsdb.com/integrations/app-integrations/confluence#confluence), [Databricks](https://docs.mindsdb.com/integrations/data-integrations/databricks#databricks), [HubSpot](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/hubspot_handler), and NetSuite handlers to improve reliability and interaction quality, resulting in smoother connections and more predictable behavior across these systems. The [Shopify](https://docs.mindsdb.com/integrations/app-integrations/shopify#shopify) handler now includes additional validation for target lists, helping prevent configuration errors before they cause issues downstream. To streamline the codebase and reduce maintenance overhead, we deprecated Dspy, Chromedb, and legacy ML handlers, making MindsDB lighter, cleaner, and easier to evolve moving forward. We also bound the extra `numba` dependency version to strengthen security and reduce potential compatibility risks. Documentation for Integrations received visual improvements as well, with images added to README files to make integration steps clearer and easier to follow. We enabled NetSuite Cloud support, expanding MindsDB’s availability across more cloud environments. This allows users to access MindsDB capabilities directly within NetSuite Cloud while giving organizations greater flexibility to operate on the platforms they are most comfortable with. Together, these updates improve stability, clarity, security, and platform reach across the ecosystem. ![](/blog/mindsdb-product-updates-february-2026/03.webp) ## **Bug Fixes and Improvements** Issues related to README locations and language permission handling has been resolved to ensure documentation is accessible and correctly structured across environments. Improvements to the [Shopify](https://docs.mindsdb.com/integrations/app-integrations/shopify#shopify) handler query limit help prevent unexpected failures when working with larger datasets, while a patched file upload vulnerability enhances overall platform security. We also addressed reported bugs affecting file datasource visibility after Docker upgrades and resolved a query charting failure that could interrupt analytics workflows. In addition, Postgres queries used for [Data Catalog](https://docs.mindsdb.com/data_catalog/overview#data-catalog) retrieval have been optimized for better efficiency. A specific issue involving aggregates from subselect statements has been fixed, significantly improving performance for more complex queries that rely on nested data selection. Together, these updates deliver stronger security, smoother upgrades, and faster, more reliable query execution for production workloads. ![](/blog/mindsdb-product-updates-february-2026/04.webp) ## **SQL Operations** We’ve delivered several stability and usability improvements across SQL handling and integrations. GROUP BY WITH ROLLUP has been fixed to make aggregations more robust and reliable, especially for advanced reporting scenarios. We added validation for the `MINDSDB_DB_CON` environment variable to prevent configuration errors and ensure smoother deployments. The `track_column` parameter is now case-insensitive, reducing friction and eliminating avoidable mistakes when defining workflows. SQL parsing has been enhanced with improved pruning of ambiguous columns and more accurate extraction of query targets in the API handler, leading to cleaner execution and fewer edge-case failures. We also improved memory handling when using [DuckDB](https://docs.mindsdb.com/integrations/data-integrations/duckdb#duckdb) to better manage resource usage under heavier workloads, and updated the available memory checks in the [Snowflake](https://docs.mindsdb.com/integrations/data-integrations/snowflake#snowflake) handler to ensure safer, more predictable query execution in cloud environments. Together, these updates improve reliability, reduce configuration errors, and strengthen performance across complex analytical workloads. ![](/blog/mindsdb-product-updates-february-2026/05.webp) ## ## **Documentation** MindsDB has removed unnecessary and unused files from the codebase as part of an ongoing effort to keep MindsDB clean, maintainable, and easier to navigate. While this may not be directly visible in day-to-day usage, it reduces technical debt, improves overall code clarity, and makes future development faster and more reliable. For users, this means a more stable platform, quicker iteration on new features, and a healthier foundation for long-term innovation. ## **Security Upgrades** MindsDB implemented multiple security upgrades across a wide range of core dependencies, including packages such as urllib3, Starlette, Keras, Protobuf, NumPy, aiohttp, Fugue, sqlparse, filelock, azure-core, pyasn1, Mintlify, sentencepiece, marshmallow, and others. These updates address known vulnerabilities, improve compatibility, and strengthen overall system resilience. For users, this means a more secure and stable platform, reduced exposure to third-party risks, and greater confidence when running MindsDB in production environments. ## **GUI** In this GUI release, we focused heavily on performance, usability, and stability to create a smoother day-to-day experience. One of the biggest changes is **unlimited tabs** in the interface. You can now open as many tabs as needed without hitting a cap, supported by improvements to IndexedDB and table data handling to ensure performance remains fast and responsive even with heavier workloads. We also refined the Respond Chat experience, improving the “thoughts” section to make interactions clearer and more intuitive. Performance was a major priority across the board. Based on Lighthouse audits, we implemented optimizations that make the interface load faster and feel more responsive. We eliminated redundant network requests when switching or updating tabs, reducing unnecessary load and improving overall efficiency. To prevent confusion during interruptions, we added a helpful popup that appears if the connection to the MindsDB server is lost, clearly explaining what happened and guiding users on next steps. We expanded functionality as well. The GUI now supports **Graph Queries**, giving users new ways to explore and visualize complex data relationships directly in the interface. In the integrations panel, we introduced clearer labeling by adding a `support_level` indicator, so users can easily see which integrations are officially supported by the MindsDB team and which are community-built. This provides better transparency around feature maturity and production readiness. A number of important bugs were resolved to improve reliability. We fixed issues that prevented adding datasources in development environments, uploading files through the GUI, and adding Amazon Bedrock as an LLM during onboarding or in model management settings. We resolved duplicate “Visualize” buttons, popup errors when canceling SQL queries, confirm button failures in the tab limit window, and visual inconsistencies related to Amazon Bedrock. Compatibility has also been aligned with Backend 26.0.0 to ensure seamless operation across versions. Under the hood, we strengthened automated testing across key areas including the Respond (Chat) tab, SQL Editor (Unify tab), Settings pages, Integrations management, Models configuration, and the “Report a Bug” feature. We also fixed an issue where the GUI was sending requests on every key press, reducing unnecessary API calls and improving responsiveness. Additional datasource form fixes now allow Hacker News and Reddit to be added successfully through the GUI. The majority of the security updates involved upgrading frontend dependencies to their latest stable or secure versions. These updates address known security alerts, improve compatibility, and ensure the interface remains protected against emerging vulnerabilities. By keeping core packages up to date, we strengthen the overall security posture of the GUI while maintaining stability and performance for users. Together, these enhancements make the interface faster, clearer, more powerful, and more reliable for building and managing AI-driven workflows. ## **Conclusion** Across Knowledge Bases, integrations, SQL operations, documentation, security, and the GUI, this release is about strengthening the core. We’ve improved ingestion performance, enhanced reliability in complex queries, increased transparency in integrations, tightened security across dependencies, and made the interface smoother and more responsive. As always, these updates are part of our ongoing effort to make MindsDB a stable, scalable, and enterprise-ready platform for building AI-powered analytics and data workflows. Thank you to our community and users for the feedback that continues to help shape each release. Check out the full [Release Notes here.](https://github.com/mindsdb/mindsdb/releases) ### Building a Semantic Search Knowledge Base with MindsDB URL: https://mindshub.ai/blog/building-a-semantic-search-knowledge-base-with-mindsdb — 2026-01-27 Learn how to build intent-based semantic search in MindsDB with Knowledge Bases, PGVector and FAISS What happens when a developer searches for "how to make async HTTP calls" but your documentation says "asynchronous network requests"? Traditional keyword search fails - even though the content is exactly what they need. This is the fundamental limitation of keyword search: it matches words, not meaning. In this tutorial, we'll build a semantic search system using MindsDB that understands user intent. Using 2 million Stack Overflow posts, we'll create knowledge bases with two different vector storage backends - **PGVector** and **FAISS** - and compare their performance. ### **What You'll Learn:** - How MindsDB knowledge bases convert text into searchable vectors - Setting up pgvector (PostgreSQL-based) and FAISS (Facebook AI Similarity Search) storage - Combining semantic search with metadata filters - Building an AI agent that uses your knowledge base to answer questions **Prerequisites:** - A MindsDB account (cloud or self-hosted) - PostgreSQL database with the Stack Overflow dataset - An OpenAI API key for embeddings ## **How Semantic Search Works** Before we dive in, let's understand the key difference between keyword and semantic search: | Aspect | Keyword Search | Semantic Search | | --- | --- | --- | | Matching | Exact words | Meaning/intent | | Query: "async HTTP" | Misses "asynchronous requests" | Finds both | | Handles synonyms | ❌ | ✅ | | Understands context | ❌ | ✅ | Semantic search works by: 1. **Embedding**: Converting text into numerical vectors using an embedding model 2. **Storing**: Saving these vectors in a vector database 3. **Querying**: Converting the search query to a vector and finding the closest matches MindsDB handles all of this through its Knowledge Base abstraction. ## **Installing Dependencies** We need two packages: - **mindsdb\_sdk**: Python client for interacting with MindsDB servers - **pandas**: For working with query results as DataFrames ```bash !pip install mindsdb_sdk pandas ``` ## **3\. Connecting to the MindsDB Cloud Instance** ```python import mindsdb_sdk # Connect to your MindsDB instance server = mindsdb_sdk.connect( 'YOUR_MINDSDB_URL', # e.g., 'https://cloud.mindsdb.com' for MindsDB Cloud login='YOUR_USERNAME', password='YOUR_PASSWORD' ) print("Connected to MindsDB server") ``` ``` Connected to MindsDB server ``` ## **4\. Connecting to the Data Source** ```python def run_query(sql, success_msg="Query executed successfully"): """Execute a SQL query and handle 'already exists' errors gracefully.""" try: result = server.query(sql).fetch() print(success_msg) return result except RuntimeError as e: if "already exists" in str(e).lower(): print("Resource already exists - skipping") else: raise return None # Connect to your PostgreSQL database containing Stack Overflow data run_query(""" CREATE DATABASE pg_sample WITH ENGINE = "postgres", PARAMETERS = { "user": "YOUR_PG_USER", "password": "YOUR_PG_PASSWORD", "host": "YOUR_PG_HOST", "port": "5432", "database": "sample" } """, "Created pg_sample database connection") ``` ``` Created pg_sample database connection ``` Let's verify the connection by exploring the data. Check the dataset size: ``` # Get total row count count = server.query("SELECT COUNT(*) as cnt FROM pg_sample.stackoverflow_2m").fetch() print(f"Dataset size: {count['cnt'].iloc[0]:,} rows") ``` ``` Dataset size: 2,000,000 rows ``` Show 10 records: ```python # Test sample data df = server.query("SELECT * FROM pg_sample.stackoverflow_2m LIMIT 10").fetch() # Display as a nice table (in Jupyter notebooks) from IPython.display import display display(df) ``` | | id | PostTypeId | AcceptedAnswerId | ParentId | Score | ViewCount | Body | Title | ContentLicense | FavoriteCount | CreationDate | LastActivityDate | LastEditDate | LastEditorUserId | OwnerUserId | Tags | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 0 | 7 | 2 | NaN | 4.0 | 522 | NaN | An explicit cast to `double` like this isn't n... | None | CC BY-SA 4.0 | NaN | 2008-07-31T22:17:57.883 | 2019-10-21T14:03:54.607 | 2019-10-21T14:03:54.607 | 5496973.0 | 9.0 | None | | 1 | 9 | 1 | 1404.0 | NaN | 2199 | 784860.0 | Given a `DateTime` representing a person's bir... | How do I calculate someone's age based on a Da... | CC BY-SA 4.0 | 0.0 | 2008-07-31T23:40:59.743 | 2023-02-02T18:38:32.613 | 2022-07-27T22:34:36.320 | 3524942.0 | 1.0 | c#,.net,datetime | | 2 | 11 | 1 | 1248.0 | NaN | 1644 | 197314.0 | Given a specific `DateTime` value, how do I di... | Calculate relative time in C# | CC BY-SA 4.0 | 0.0 | 2008-07-31T23:55:37.967 | 2022-09-05T11:26:30.187 | 2022-07-10T00:19:55.237 | 16790137.0 | 1.0 | c#,datetime,time,datediff,relative-time-span | | 3 | 14 | 1 | NaN | NaN | 491 | 173083.0 | What is the difference between [Math.Floor()](... | Difference between Math.Floor() and Math.Trunc... | CC BY-SA 3.0 | 0.0 | 2008-08-01T00:59:11.177 | 2022-04-22T08:59:43.817 | 2017-02-25T17:42:17.810 | 6495084.0 | 11.0 | .net,math | | 4 | 6 | 1 | 31.0 | NaN | 319 | 23465.0 | I have an absolutely positioned `div` containi... | Why did the width collapse in the percentage w... | CC BY-SA 4.0 | 0.0 | 2008-07-31T22:08:08.620 | 2021-01-29T18:46:45.963 | 2021-01-29T18:46:45.963 | 9134576.0 | 9.0 | html,css,internet-explorer-7 | | 5 | 12 | 2 | NaN | 11.0 | 347 | NaN | Here's how I do it\n\n```\nvar ts = new TimeSp... | None | CC BY-SA 4.0 | NaN | 2008-07-31T23:56:41.303 | 2020-06-13T10:30:44.397 | 2020-06-13T10:30:44.397 | 238419.0 | 1.0 | None | | 6 | 13 | 1 | NaN | NaN | 701 | 277780.0 | Is there a standard way for a web server to be... | Determine a user's timezone | CC BY-SA 4.0 | 0.0 | 2008-08-01T00:42:38.903 | 2022-03-29T07:31:31.320 | 2020-12-03T03:37:56.313 | 584192.0 | 9.0 | html,browser,timezone,user-agent,timezone-offset | | 7 | 4 | 1 | 7.0 | NaN | 794 | 70633.0 | I want to assign the decimal variable "trans" ... | How to convert Decimal to Double in C#? | CC BY-SA 4.0 | 0.0 | 2008-07-31T21:42:52.667 | 2022-09-08T05:07:26.033 | 2022-09-08T05:07:26.033 | 16124033.0 | 8.0 | c#,floating-point,type-conversion,double,decimal | | 8 | 17 | 1 | 26.0 | NaN | 198 | 85547.0 | How do I store binary data in [MySQL](http://e... | Binary Data in MySQL | CC BY-SA 3.0 | 0.0 | 2008-08-01T05:09:55.993 | 2020-12-03T03:37:51.763 | 2020-12-03T03:37:51.763 | 584192.0 | 2.0 | mysql,database,binary-data,data-storage | | 9 | 24 | 1 | 49.0 | NaN | 193 | 101180.0 | If I have a trigger before the update on a tab... | Throw an error preventing a table update in a ... | CC BY-SA 4.0 | 0.0 | 2008-08-01T12:12:19.350 | 2021-01-29T12:57:17.153 | 2021-01-29T12:57:17.153 | 14152908.0 | 22.0 | mysql,database,triggers | The Stack Overflow dataset contains 2 million posts - both questions (`PostTypeId=1`) and answers (`PostTypeId=2`). Key columns include: - `Id` - Unique identifier for each post - `Body` - The content we'll make semantically searchable - `Title` - The title of the post (questions only) - `Tags` - Programming language and topic tags (e.g., `python`, `javascript`) - `Score` - Community voting score - useful for prioritizing high-quality content - `ViewCount` - Popularity metric for filtering - `PostTypeId` - Type of post (1=question, 2=answer) - `AcceptedAnswerId` - ID of the accepted answer (for questions) - `CreationDate`, `LastActivityDate`, `LastEditDate` - Timestamps This rich metadata allows us to combine semantic understanding with traditional filters - for example, finding Python questions about async programming with a score above 10. ## **4\. Setting Up Vector Storage Backends** MindsDB supports multiple vector storage options. We'll set up both pgvector and a recently added FAISS and will compare how quick they are. ### **PGVector (PostgreSQL Extension)** pgvector is a PostgreSQL extension for vector similarity search. It's ideal when you want to keep vectors alongside your relational data. ```sql # Create pgvector database connection run_query(""" CREATE DATABASE pg_vector WITH ENGINE = "pgvector", PARAMETERS = { "user": "YOUR_PG_USER", "password": "YOUR_PG_PASSWORD", "host": "YOUR_PG_HOST", "port": "5432", "database": "vector" } """, "Created pg_vector database connection") ``` ``` Created pg_vector database connection ``` ### **FAISS (Facebook AI Similarity Search)** FAISS is a library for efficient similarity search developed by Facebook AI Research. It's optimized for fast similarity search on large datasets. ```sql # Create FAISS database connection run_query(""" CREATE DATABASE db_faiss WITH ENGINE = 'duckdb_faiss', PARAMETERS = { "persist_directory": "/home/ubuntu/faiss" } """, "Created db_faiss database connection") ``` ``` Created db_faiss database connection ``` ## **Choosing Between PGVector and FAISS** | Feature | pgvector | FAISS | | --- | --- | --- | | Best for | Integration with existing PostgreSQL | Maximum query speed | | Persistence | Native PostgreSQL storage | File-based | | Scalability | Good (PostgreSQL limits) | Excellent (billions of vectors) | | Setup complexity | Requires PostgreSQL extension | Standalone | | Query speed | Good (~19s for 2M vectors) | Excellent (~5s for 2M vectors) | For this tutorial, we'll implement both so you can see the performance difference firsthand. ## **5\. Creating Knowledge Bases** Now we have a table with relational data and two vector stores to keep the embedding vectors. We are ready to create knowledge bases using both storage backends. The knowledge base will: - Use OpenAI's `text-embedding-3-small` model for generating embeddings - Store the post `Body` as searchable content - Include metadata fields for filtering results ### **Knowledge Base with PGVector Storage** ```python def kb_exists(kb_name): """Check if a knowledge base already exists.""" try: result = server.query("SELECT name FROM information_schema.knowledge_bases").fetch() return kb_name in result['name'].values except Exception: return False # Create pgvector knowledge base if kb_exists("kb_stack_vector"): print("kb_stack_vector already exists - skipping creation") else: run_query(""" CREATE KNOWLEDGE_BASE kb_stack_vector USING storage = pg_vector.stack, embedding_model = { "provider": "openai", "model_name": "text-embedding-3-small" }, content_columns = ['Body'], metadata_columns = [ "PostTypeId", "AcceptedAnswerId", "ParentId", "Score", "ViewCount", "Title", "ContentLicense", "FavoriteCount", "CreationDate", "LastActivityDate", "LastEditDate", "LastEditorUserId", "OwnerUserId", "Tags" ] """, "Created kb_stack_vector knowledge base") ``` ``` Created kb_stack_vector knowledge base ``` ### **Knowledge Base with FAISS Storage** ```sql # Create FAISS knowledge base if kb_exists("kb_stack_faiss"): print("kb_stack_faiss already exists - skipping creation") else: run_query(""" CREATE KNOWLEDGE_BASE kb_stack_faiss USING storage = db_faiss.stack, embedding_model = { "provider": "openai", "model_name": "text-embedding-3-small" }, content_columns = ['Body'], metadata_columns = [ "PostTypeId", "AcceptedAnswerId", "ParentId", "Score", "ViewCount", "Title", "ContentLicense", "FavoriteCount", "CreationDate", "LastActivityDate", "LastEditDate", "LastEditorUserId", "OwnerUserId", "Tags" ] """, "Created kb_stack_faiss knowledge base") ``` ``` Created kb_stack_faiss knowledge base ``` ### **Understanding the Parameters** | Parameter | Description | | --- | --- | | storage | Specifies the vector database connection and table name | | embedding_model | Configuration for the embedding model (provider and model name) | | content_columns | Columns to embed and make semantically searchable | | metadata_columns | Columns available for filtering (not embedded, but stored) | ## **6\. Loading Data into Knowledge Bases** Now we'll insert the Stack Overflow data into our knowledge bases. This process: 1. Fetches data from the source table in batches 2. Generates embeddings for content columns using the OpenAI API 3. Stores vectors and metadata in the vector database ### **Loading Data into PGVector Knowledge Base** ```python def is_kb_empty(kb_name): """Check if a knowledge base is empty (fast - only fetches 1 row).""" result = server.query(f"SELECT id FROM {kb_name} LIMIT 1").fetch() return len(result) == 0 if is_kb_empty("kb_stack_vector"): print("kb_stack_vector is empty - starting data insertion...") server.query(""" INSERT INTO kb_stack_vector SELECT * FROM pg_sample.stackoverflow_2m USING batch_size = 1000, track_column = id """).fetch() print("Data insertion started for kb_stack_vector") else: print("kb_stack_vector is not empty - skipping data insertion") ``` ``` Data insertion started for kb_stack_vector ``` ### **Loading Data into FAISS Knowledge Base** ```sql if is_kb_empty("kb_stack_faiss"): print("kb_stack_faiss is empty - starting data insertion...") server.query(""" INSERT INTO kb_stack_faiss SELECT * FROM pg_sample.stackoverflow_2m USING batch_size = 1000, track_column = id """).fetch() print("Data insertion started for kb_stack_faiss") else: print("kb_stack_faiss is not empty - skipping data insertion") ``` ``` Data insertion started for kb_stack_faiss ``` Wait until the data insertion is complete. ## **7\. Querying the Knowledge Bases** Once data is loaded, you can perform semantic searches combined with metadata filtering. ### **Basic Semantic Search** Search for content related to "8-bit music" (finds semantically similar content): ```python import time # Semantic search on pgvector KB start = time.time() results_vector = server.query(""" SELECT * FROM kb_stack_vector WHERE content = '8-bit music' AND Tags LIKE '%python%' LIMIT 10 """).fetch() elapsed_vector = time.time() - start print(f"pgvector query time: {elapsed_vector:.2f} seconds") display(results_vector) # Semantic search on FAISS KB start = time.time() results_faiss = server.query(""" SELECT * FROM kb_stack_faiss WHERE content = '8-bit music' AND Tags LIKE '%python%' LIMIT 10 """).fetch() elapsed_faiss = time.time() - start print(f"FAISS query time: {elapsed_faiss:.2f} seconds") display(results_faiss) ``` ``` pgvector query time: 19.21 seconds ``` | | id | chunk_id | chunk_content | distance | relevance | ContentLicense | ViewCount | LastEditDate | Score | AcceptedAnswerId | OwnerUserId | LastActivityDate | Tags | LastEditorUserId | PostTypeId | ParentId | Title | FavoriteCount | CreationDate | metadata | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 0 | 1118266 | 1118266:Body:1of2:0to971 | Im trying to engineer in python a way of trans... | 0.605447 | 0.622879 | CC BY-SA 2.5 | 1694.0 | 2009-07-13T08:32:20.797 | 0 | NaN | NaN | 2010-03-17T15:16:17.060 | python,audio | 12855.0 | 1 | None | List of values to a sound file | NaN | 2009-07-13T08:27:25.393 | {'Tags': 'python,audio', 'Score': 0, 'Title': ... | | 1 | 974071 | 974071:Body:1of1:0to791 | I have a mosquito problem in my house. This wo... | 0.615257 | 0.619097 | CC BY-SA 2.5 | 55695.0 | 2017-05-23T12:32:21.507 | 44 | 974291.0 | 51197.0 | 2020-02-12T22:24:39.977 | python,audio,mp3,frequency | -1.0 | 1 | None | Python library for playing fixed-frequency sound | 0.0 | 2009-06-10T07:05:02.037 | {'Tags': 'python,audio,mp3,frequency', 'Score'... | | 2 | 1967040 | 1967040:Body:1of1:0to224 | I am confused because there are a lot of progr... | 0.626904 | 0.614665 | CC BY-SA 2.5 | 6615.0 | None | 7 | 1968691.0 | 237934.0 | 2021-08-10T10:40:59.217 | python,audio | NaN | 1 | None | How can i create a melody? Is there any sound-... | 0.0 | 2009-12-27T21:04:34.243 | {'Tags': 'python,audio', 'Score': 7, 'Title': ... | | 3 | 1118266 | 1118266:Body:2of2:972to1430 | The current solution I'm thinking of involves ... | 0.627442 | 0.614461 | CC BY-SA 2.5 | 1694.0 | 2009-07-13T08:32:20.797 | 0 | NaN | NaN | 2010-03-17T15:16:17.060 | python,audio | 12855.0 | 1 | None | List of values to a sound file | NaN | 2009-07-13T08:27:25.393 | {'Tags': 'python,audio', 'Score': 0, 'Title': ... | | 4 | 1344884 | 1344884:Body:1of1:0to327 | I want to learn how to program a music applica... | 0.643957 | 0.608289 | CC BY-SA 2.5 | 2205.0 | 2017-05-23T12:11:22.607 | 7 | 1346272.0 | 164623.0 | 2022-04-14T09:12:07.197 | python,perl,waveform | -1.0 | 1 | None | Programming a Self Learning Music Maker | 0.0 | 2009-08-28T03:28:03.937 | {'Tags': 'python,perl,waveform', 'Score': 7, '... | | 5 | 2376505 | 2376505:Body:1of2:0to968 | Write a function called listenToPicture that t... | 0.645214 | 0.607824 | CC BY-SA 2.5 | 3058.0 | 2010-03-04T02:28:26.703 | 0 | NaN | 285922.0 | 2010-03-06T05:27:48.017 | python,image,audio | 34397.0 | 1 | None | How do I loop through every 4th pixel in every... | NaN | 2010-03-04T02:26:22.603 | {'Tags': 'python,image,audio', 'Score': 0, 'Ti... | | 6 | 2226853 | 2226853:Body:1of1:0to877 | I'm trying to write a program to display PCM d... | 0.654162 | 0.604536 | CC BY-SA 2.5 | 12425.0 | None | 7 | 2226907.0 | 210920.0 | 2015-07-25T11:16:16.747 | python,audio,pcm | NaN | 1 | None | Interpreting WAV Data | 0.0 | 2010-02-09T05:01:25.703 | {'Tags': 'python,audio,pcm', 'Score': 7, 'Titl... | | 7 | 1561104 | 1561104:Body:1of1:0to306 | Is there a way to do this? Also, I need this t... | 0.668074 | 0.599494 | CC BY-SA 2.5 | 1303.0 | 2020-06-20T09:12:55.060 | 1 | 1561314.0 | 151377.0 | 2012-01-29T00:01:18.230 | python,pygame,pitch | -1.0 | 1 | None | Playing sounds with python and changing their ... | NaN | 2009-10-13T15:44:54.267 | {'Tags': 'python,pygame,pitch', 'Score': 1, 'T... | | 8 | 1382998 | 1382998:Body:4of4:2649to3382 | ```\n¼ éíñ§ÐÌëÑ » ¼ ö ® © ’\n0 1\n2 10\n3 10\n... | 0.670654 | 0.598568 | CC BY-SA 3.0 | 12497.0 | 2011-06-09T06:00:51.243 | 18 | 1383721.0 | 6946.0 | 2015-06-04T17:13:43.323 | python,unicode | 6946.0 | 1 | None | latin-1 to ascii | 0.0 | 2009-09-05T10:44:40.167 | {'Tags': 'python,unicode', 'Score': 18, 'Title... | | 9 | 1837686 | 1837686:Body:1of2:0to950 | I wish to take a file encoded in UTF-8 that do... | 0.675999 | 0.596659 | CC BY-SA 3.0 | 3016.0 | 2011-10-15T13:17:24.520 | 2 | NaN | NaN | 2011-10-15T13:17:24.520 | python,c,utf-8,compression | 12113.0 | 1 | None | Compressing UTF-8(or other 8-bit encoding) to ... | 0.0 | 2009-12-03T04:43:05.963 | {'Tags': 'python,c,utf-8,compression', 'Score'... | ``` FAISS query time: 5.04 seconds ``` | | id | distance | chunk_id | chunk_content | relevance | ContentLicense | ViewCount | LastEditDate | Score | AcceptedAnswerId | OwnerUserId | ParentId | LastEditorUserId | LastActivityDate | Tags | PostTypeId | FavoriteCount | Title | CreationDate | metadata | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 0 | 1118266 | 0.605468 | 1118266:Body:1of2:0to971 | Im trying to engineer in python a way of trans... | 0.622871 | CC BY-SA 2.5 | 1694.0 | 2009-07-13T08:32:20.797 | 0 | NaN | NaN | None | 12855.0 | 2010-03-17T15:16:17.060 | python,audio | 1 | NaN | List of values to a sound file | 2009-07-13T08:27:25.393 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 1 | 974071 | 0.615225 | 974071:Body:1of1:0to791 | I have a mosquito problem in my house. This wo... | 0.619109 | CC BY-SA 2.5 | 55695.0 | 2017-05-23T12:32:21.507 | 44 | 974291.0 | 51197.0 | None | -1.0 | 2020-02-12T22:24:39.977 | python,audio,mp3,frequency | 1 | 0.0 | Python library for playing fixed-frequency sound | 2009-06-10T07:05:02.037 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 2 | 1967040 | 0.626923 | 1967040:Body:1of1:0to224 | I am confused because there are a lot of progr... | 0.614657 | CC BY-SA 2.5 | 6615.0 | None | 7 | 1968691.0 | 237934.0 | None | NaN | 2021-08-10T10:40:59.217 | python,audio | 1 | 0.0 | How can i create a melody? Is there any sound-... | 2009-12-27T21:04:34.243 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 3 | 1118266 | 0.627461 | 1118266:Body:2of2:972to1430 | The current solution I'm thinking of involves ... | 0.614454 | CC BY-SA 2.5 | 1694.0 | 2009-07-13T08:32:20.797 | 0 | NaN | NaN | None | 12855.0 | 2010-03-17T15:16:17.060 | python,audio | 1 | NaN | List of values to a sound file | 2009-07-13T08:27:25.393 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 4 | 1344884 | 0.643955 | 1344884:Body:1of1:0to327 | I want to learn how to program a music applica... | 0.608289 | CC BY-SA 2.5 | 2205.0 | 2017-05-23T12:11:22.607 | 7 | 1346272.0 | 164623.0 | None | -1.0 | 2022-04-14T09:12:07.197 | python,perl,waveform | 1 | 0.0 | Programming a Self Learning Music Maker | 2009-08-28T03:28:03.937 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 5 | 2376505 | 0.645192 | 2376505:Body:1of2:0to968 | Write a function called listenToPicture that t... | 0.607832 | CC BY-SA 2.5 | 3058.0 | 2010-03-04T02:28:26.703 | 0 | NaN | 285922.0 | None | 34397.0 | 2010-03-06T05:27:48.017 | python,image,audio | 1 | NaN | How do I loop through every 4th pixel in every... | 2010-03-04T02:26:22.603 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 6 | 2226853 | 0.654112 | 2226853:Body:1of1:0to877 | I'm trying to write a program to display PCM d... | 0.604554 | CC BY-SA 2.5 | 12425.0 | None | 7 | 2226907.0 | 210920.0 | None | NaN | 2015-07-25T11:16:16.747 | python,audio,pcm | 1 | 0.0 | Interpreting WAV Data | 2010-02-09T05:01:25.703 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 7 | 1561104 | 0.668055 | 1561104:Body:1of1:0to306 | Is there a way to do this? Also, I need this t... | 0.599501 | CC BY-SA 2.5 | 1303.0 | 2020-06-20T09:12:55.060 | 1 | 1561314.0 | 151377.0 | None | -1.0 | 2012-01-29T00:01:18.230 | python,pygame,pitch | 1 | NaN | Playing sounds with python and changing their ... | 2009-10-13T15:44:54.267 | {'ContentLicense': 'CC BY-SA 2.5', 'LastActivi... | | 8 | 1382998 | 0.670668 | 1382998:Body:4of4:2649to3382 | ```\n¼ éíñ§ÐÌëÑ » ¼ ö ® © ’\n0 1\n2 10\n3 10\n... | 0.598563 | CC BY-SA 3.0 | 12497.0 | 2011-06-09T06:00:51.243 | 18 | 1383721.0 | 6946.0 | None | 6946.0 | 2015-06-04T17:13:43.323 | python,unicode | 1 | 0.0 | latin-1 to ascii | 2009-09-05T10:44:40.167 | {'ContentLicense': 'CC BY-SA 3.0', 'LastActivi... | | 9 | 1837686 | 0.675986 | 1837686:Body:1of2:0to950 | I wish to take a file encoded in UTF-8 that do... | 0.596664 | CC BY-SA 3.0 | 3016.0 | 2011-10-15T13:17:24.520 | 2 | NaN | NaN | None | 12113.0 | 2011-10-15T13:17:24.520 | python,c,utf-8,compression | 1 | 0.0 | Compressing UTF-8(or other 8-bit encoding) to ... | 2009-12-03T04:43:05.963 | {'ContentLicense': 'CC BY-SA 3.0', 'LastActivi... | ## **Analyzing the Results** Notice how the search for "8-bit music" returned posts about: - Converting values to sound files - Playing fixed-frequency sounds - Creating melodies programmatically None of these posts contain the exact phrase "8-bit music," yet they're all semantically relevant to chiptune/retro audio generation. This is the power of semantic search. Also note the **4x speed improvement** with FAISS (5 seconds vs 19 seconds for pgvector). For production systems with high query volumes, this difference is significant. ### **Combined Semantic and Metadata Filtering** Find AJAX-related posts tagged with jQuery that have high view counts: ```sql # pgvector: Semantic search with metadata filters start = time.time() results = server.query(""" SELECT * FROM kb_stack_vector WHERE content = 'ajax' AND Tags LIKE '%jquery%' AND ViewCount > 1000.0 AND relevance > 0.6 LIMIT 10 """).fetch() print(f"pgvector query time: {time.time() - start:.2f} seconds") display(results) # FAISS: Semantic search with metadata filters start = time.time() results = server.query(""" SELECT * FROM kb_stack_faiss WHERE content = 'ajax' AND Tags LIKE '%jquery%' AND ViewCount > 1000.0 AND relevance > 0.6 LIMIT 10 """).fetch() print(f"FAISS query time: {time.time() - start:.2f} seconds") display(results) ``` ``` pgvector query time: 5.76 seconds ``` | | id | chunk_id | chunk_content | distance | relevance | ContentLicense | ViewCount | LastEditDate | Score | AcceptedAnswerId | OwnerUserId | LastActivityDate | Tags | LastEditorUserId | PostTypeId | ParentId | Title | FavoriteCount | CreationDate | metadata | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 0 | 1400637 | 1400637:Body:28of32:25627to26627 | o.ajax({type:"POST",url:E,data:G,success:H,dat... | 0.427265 | 0.700641 | CC BY-SA 2.5 | 2741.0 | 2009-09-09T16:16:59.430 | 2 | 1400656.0 | 107129.0 | 2013-08-05T16:07:54.400 | javascript,jquery | 8590.0 | 1 | None | Stop reload for ajax submitted form | NaN | 2009-09-09T16:12:46.057 | {'Tags': 'javascript,jquery', 'Score': 2, 'Tit... | | 1 | 1400637 | 1400637:Body:30of32:27488to28356 | O=false;T.onload=T.onreadystatechange=function... | 0.453764 | 0.687870 | CC BY-SA 2.5 | 2741.0 | 2009-09-09T16:16:59.430 | 2 | 1400656.0 | 107129.0 | 2013-08-05T16:07:54.400 | javascript,jquery | 8590.0 | 1 | None | Stop reload for ajax submitted form | NaN | 2009-09-09T16:12:46.057 | {'Tags': 'javascript,jquery', 'Score': 2, 'Tit... | | 2 | 1400637 | 1400637:Body:27of32:24691to25626 | rn this},serialize:function(){return o.param(t... | 0.454629 | 0.687460 | CC BY-SA 2.5 | 2741.0 | 2009-09-09T16:16:59.430 | 2 | 1400656.0 | 107129.0 | 2013-08-05T16:07:54.400 | javascript,jquery | 8590.0 | 1 | None | Stop reload for ajax submitted form | NaN | 2009-09-09T16:12:46.057 | {'Tags': 'javascript,jquery', 'Score': 2, 'Tit... | | 3 | 1424774 | 1424774:Body:2of2:934to1745 | var self = this;\n $.ajax({\n ... | 0.461486 | 0.684235 | CC BY-SA 2.5 | 3601.0 | None | 1 | 1426940.0 | 173350.0 | 2020-06-08T10:43:45.037 | jquery,loops | NaN | 1 | None | Loop with 8 times | NaN | 2009-09-15T02:02:58.927 | {'Tags': 'jquery,loops', 'Score': 1, 'Title': ... | | 4 | 1400637 | 1400637:Body:31of32:28357to29238 | N=function(X){if(J.readyState==0){if(P){clearI... | 0.462191 | 0.683905 | CC BY-SA 2.5 | 2741.0 | 2009-09-09T16:16:59.430 | 2 | 1400656.0 | 107129.0 | 2013-08-05T16:07:54.400 | javascript,jquery | 8590.0 | 1 | None | Stop reload for ajax submitted form | NaN | 2009-09-09T16:12:46.057 | {'Tags': 'javascript,jquery', 'Score': 2, 'Tit... | | 5 | 546344 | 546344:Body:2of3:902to1764 | var before = function() { $(loading).show() ;... | 0.463258 | 0.683407 | CC BY-SA 2.5 | 1463.0 | 2009-02-13T16:17:38.170 | 0 | 546642.0 | 2755.0 | 2009-02-13T16:37:59.867 | javascript,jquery,ajax | 2755.0 | 1 | None | Using jQuery, how can I store the result of a ... | 0.0 | 2009-02-13T15:25:00.963 | {'Tags': 'javascript,jquery,ajax', 'Score': 0,... | | 6 | 1279625 | 1279625:Body:2of3:782to1754 | ```\n\n\n\n\n