Tether BotPsy AI: How Its Small Agent Controls Devices
See how Tether’s 800-million-parameter BotPsy agent handles tool-use tasks, what its benchmark results show, and why local AI still has important limits.

Tether's BotPsy Puts a Small AI Agent to Work on Your Device
An AI assistant is only useful when it can do more than answer questions. It has to change a setting, call the right tool, recover when something goes wrong, and actually finish the task. That's the gap Tether says it's trying to fill with BotPsy - an 800-million-parameter AI agent built to work with software on personal devices.
Tether reports BotPsy outperformed models up to 2.5 times larger on five of six tool-use evaluations. The practical appeal is obvious: a smaller model may be easier to run locally, which can reduce how often personal data has to be sent to the cloud for each task. Still, benchmark wins don't automatically translate into a reliable assistant on a real phone. Local execution also doesn't, by itself, mean something is private or safe.
This article breaks down what BotPsy is meant to do, what Tether's reported results likely measure, and how it fits into the company's QVAC effort. It also separates the real promise of on-device agents from what still needs to happen before you'd trust one as a consumer assistant.
What is Tether's BotPsy AI agent?
BotPsy is a language model tuned to use software tools. That's different from a general chatbot that mainly generates text in response to prompts. Tether describes it as an agent: a system that can pick an action, run it through an available tool, and then respond based on the result. On a phone, that could mean walking through multiple steps instead of just telling you which button to tap.
The model is based on Alibaba's Qwen3.5-0.8B architecture and has 800 million parameters. Parameters are learned numbers that shape what the model outputs. Fewer parameters can mean lower memory needs, but parameter count alone doesn't tell you how capable a model is. Training approach, task design, the inference setup, and - crucially - the tools the model can access all matter.
The difference between "chat" and "act" is the key point. If you ask a chatbot to send a message, it can draft the text. An agent has to identify the correct messaging tool, supply the right arguments, handle permission prompts, and deal with failures when something doesn't work. In other words, the model isn't doing all of that on its own - it depends on the surrounding software to expose tools and enforce what it's allowed to do.
Tether's example is meant to show that kind of recovery. In the scenario, the assistant had to send a message, but Wi-Fi was off and the inbox was full. BotPsy reportedly turned Wi-Fi back on, freed enough storage, and then finished the task. The interesting part, according to Tether, isn't that the task was complex. It's that the system kept hitting a failure, then tried to identify why, and took a corrective step.
That's a sensible target for a smaller model. A phone agent doesn't need to reason about every topic like a frontier system. It needs to carry out a bounded set of actions consistently, while the operating system or app controls access. If the full setup - including permissions, error handling, and user confirmation - does its job, a compact model can be practical.
How well does BotPsy perform on tool-use benchmarks?
Tether's documentation reports results across six tool-use evaluations. BotPsy scored an average of 45.0% and ranked first on five of the six tests among the five models Tether compared. The company also says BotPsy outperformed models with up to 2.5 times its parameter count. These are company-reported benchmark results, so they're useful as evidence about those specific test tasks - not a guarantee of everyday performance.
Two of the results are worth looking at. On BFCL v4, which evaluates selecting and executing software functions across tasks and conversations, BotPsy scored 44.0%. Its base model, Qwen3.5-0.8B, scored 23.4%, while Qwen3.5-2B scored 37.7%. On ACEBench, which measures accuracy of function calls, including choosing tools and providing arguments, BotPsy scored 58.7%. The base model scored 30.1%, and Qwen3.5-2B scored 55.4%.
Taken together, the comparison suggests BotPsy's extra training helped a lot with tool use. It doesn't prove BotPsy is a stronger general-purpose language model, and it doesn't mean model size stops mattering. The more limited claim is the one tied to these evaluations: tuned 800-million-parameter BotPsy did better than the particular larger models included in Tether's test set.
What the scores do - and do not - tell you
Benchmarks help when they measure a capability that actually matters for the product. Correct tool selection and argument accuracy are directly relevant for an agent that has to call apps correctly. But benchmark tasks are still simplified and controlled. Real devices bring messy realities: changing interfaces, ambiguous requests, permissions, network interruptions, and consequences that are harder to undo than a failed test call.
The scores also don't answer basic deployment questions. How does BotPsy perform across different phone models, operating systems, languages, and third-party apps? How often does it ask for clarification? How long do tasks take? How much battery does it burn? Can users inspect what it did and reverse it if something goes off track?
The most honest takeaway is this: BotPsy looks specialized for tool use and shows promising results in the evaluations Tether published. If you want it as a product, you'd still need independent testing on realistic workflows - measuring success rates, error severity, and recovery behavior from end to end. A strong benchmark score is a reason to investigate, not a replacement for testing the system in the hands of real users.
Why does on-device AI matter to Tether and crypto?
BotPsy is part of QVAC, Tether's effort to build AI systems that can run on devices users control, rather than relying entirely on centralized cloud infrastructure. The appeal is straightforward: when tasks can be processed locally, fewer personal details may need to leave the device. Local inference can also keep an app working when connectivity is limited, though what an agent can actually do depends on the model and the application integrating it.
For Tether, QVAC sits alongside its stablecoin business. Tether has talked about autonomous agents that interact with applications and potentially make payments using Bitcoin and USDT. That's where AI agents and crypto infrastructure start to intersect. But BotPsy itself shouldn't be treated as a wallet, a payment rail, or an autonomous trading system. Tether's stated focus for BotPsy is handling everyday software tasks, while payment-related capabilities appear to be a longer-term goal for the wider ecosystem.
The distinction matters because an agent that can use tools eventually bumps into financial apps. That creates both opportunities, like less friction in routine flows, and real risks. A wrong calendar entry is annoying; an unauthorized transfer or a poorly scoped payment can be damaging. Any financial use would need strong permission controls, clear review steps for transactions, and guardrails that don't rely solely on the model interpreting a prompt correctly.
QVAC is broader than one model
Tether introduced QVAC as an ecosystem, not a single assistant. The work includes models for medical use cases, translation, and speech processing, plus QVAC Workbench for running models locally and an SDK aimed at helping developers build offline AI apps across mobile and desktop systems. BotPsy adds another piece by targeting software interaction.
This ecosystem approach is strategically plausible. Smaller, specialized models can be easier to deploy on consumer hardware than very large systems, and a shared local stack can support more than one app. But "ecosystem" doesn't automatically mean everything is mature or interoperable. Developers still have to wire models into device permissions, user interfaces, updates, and secure storage.
For crypto, the most important questions aren't about whether something can be described as decentralized. They're about where computation happens, who controls the software and keys, what data leaves the device, and who is responsible when something goes wrong. Local inference can improve part of that picture. It doesn't automatically decentralize an application or make a financial workflow safe.
What are BotPsy's limits for real-world use?
The first limit is the gap between an open-weight model and a finished assistant. Tether released BotPsy under the Apache 2.0 license, which lets developers download, modify, and integrate the model. The company also released compressed versions to reduce memory requirements. That lowers the barrier to experimentation and local deployment - but it doesn't eliminate the need for an application layer that connects the model to device functions and provides proper safeguards.
Tether hasn't announced a release date for a finished consumer assistant powered by BotPsy. The model card also doesn't include training code or training data. That doesn't mean the model is unusable, but it does mean outside developers and evaluators have less to reproduce or audit about how it was trained. If you're evaluating it, it's worth keeping the distinction clear: open weights are not the same thing as a fully reproducible training process.
Privacy is another area where the details matter. Running inference locally can reduce the need to send prompts to a remote model provider. That can be a real privacy advantage, but it isn't a blanket guarantee. An app could still send telemetry, sync data, or call cloud services for other features. A device can also be compromised, and local data might still be exposed if storage and permissions are poorly handled. You need to look at the whole application flow, not just where the model runs.
Reliability and authorization are equally important. If an agent can change settings or send messages, it needs boundaries: which tools it can use, what actions require confirmation, and how it reports partial failure. For low-risk tasks, automatic execution can save time. For actions involving financial, legal, or personal consequences, adding a user review step is a reasonable trade-off, even if it slows the workflow down.
A practical evaluation checklist
If you're considering BotPsy as a developer, test the full task flow - not just the benchmark score. Start with normal tasks, then deliberately introduce failure modes like missing permissions or unavailable connectivity. Track how often the agent succeeds, whether it recognizes errors, and whether it asks for help when it can't proceed safely.
Before integrating, check:
- Device fit: Can the model run within the memory, latency, and battery limits of your target hardware?
- Tool boundaries: Can you restrict access to only the actions your app actually needs?
- Recovery: When a step fails, does the agent stop, explain what happened, or ask for confirmation?
- Data handling: Which prompts, logs, and device details stay local, and which are transmitted?
- High-impact actions: Are financial transfers, message sending, or destructive changes gated by explicit user approval?
- Reproducibility: Is the documentation enough for your security and maintenance needs?
The "right" decision depends on the job. For a narrow offline workflow, a compact local model can make sense. For tasks that need broad knowledge or very high confidence, a larger or cloud-based system may perform better - but it brings different costs and data-handling trade-offs. The best comparison isn't just "small versus large." It's accuracy, privacy, latency, cost, and failure behavior for the specific task you're trying to support.
Conclusion: What BotPsy signals for local AI
BotPsy looks like a focused attempt to solve a problem many assistants still struggle with: turning a request into a sequence of actions, choosing tools, and recovering when a step fails. Tether's benchmark results are encouraging - especially compared to the base model and the larger Qwen model it tested. But these are still company results, and they measure a narrower capability than "reliable on a phone in real life."
The real test will be what happens when the model is connected to actual apps. Developers will need to validate performance on target devices, limit tool access, make failures visible, and require confirmation for consequential actions. Users also need to separate "local inference" from end-to-end privacy, and "open weights" from a fully documented training process.
For now, the most accurate framing is this: BotPsy is an open-weight building block for Tether's local AI effort - not a finished phone assistant, and not a crypto payment agent. Its value will depend on whether developers can turn its tool-use ability into dependable workflows without surrendering control over data, permissions, and decisions.