Documentation
From installation to mastery — a comprehensive guide to all Tokeny features and usage.
Start with a practical guide
Install Tokeny and complete your first task
Choose an installer, configure a model and create a workspace. Complete a small task with an outcome you can verify.
Models and data flows
Compare your own API key, Tokeny channels and local models. Understand which data leaves your computer and how to check your setup.
Install, verify and troubleshoot MCP servers
Connect MCP servers with verified MarkItDown and Serena commands. Review versions, tool discovery and the limits of six server checks.
Turn CSV orders into an Excel report
Use synthetic orders to calculate revenue, build Excel formulas and a category chart, and reconcile the result against known totals.
Turn meeting notes into a Word document
Extract decisions, owners, due dates and open questions from synthetic meeting notes, then produce a Word document for review.
Skills vs MCP: differences and combinations
Skills describe workflows; MCP exposes callable tools. Learn how to combine them to convert source material and prepare a report.
Installation & Setup
Download Installer
Tokeny supports Windows, macOS, and Linux. Go to the download section on the homepage — it automatically detects your device and recommends the right installer, and you can also switch platforms manually:
- Windows: Download the .exe installer and double-click it to run the setup wizard
- macOS: Download the .dmg file and drag it to the Applications folder (separate builds for Apple silicon and Intel chips)
- Linux: Download the Linux (x64) package
First Launch & Sign-in
Tokeny is ready to use right after the first launch. The app creates a local SQLite database to store your conversations, settings, and file data.
After launching, you can sign in with your Tokeny unified account — the same account used on the official website tokeny-ai.com. Sign in with your phone number (SMS code or password) or by scanning a WeChat QR code. Signing in unlocks online features such as membership benefits and one-click installs and submissions in the marketplace. Without signing in, you can still use local features with your own provider API Keys.
Before your first conversation, set up a model channel: enter at least one provider API Key in the "AI Models" settings.
System Requirements
| Platform | Minimum Requirements |
|---|---|
| Windows | Windows 10 (64-bit) or later |
| macOS | macOS 11 (Big Sur) or later, supports both Apple silicon and Intel chips |
| Linux | Mainstream 64-bit distributions |
Built-in vs System Environment
Tokeny offers two ways to manage runtime environments, ensuring you can get started without complex configuration:
| Mode | Description | Best For |
|---|---|---|
| Built-in (Default) | Portable Node.js and Python bundled with the app. One-click extraction on first launch, versions verified for compatibility | All users, works out of the box, recommended |
| System (Fallback) | When the built-in environment is unavailable, automatically falls back to Node.js and Python installed on your computer | Backup when built-in environment has issues |
Tokeny prioritizes the built-in environment: the bundled runtime versions are verified for compatibility and stability. System-installed versions are only used as a fallback when the built-in environment is unavailable. You don't need to manually install Node.js, Python, or other dependencies — just initialize the built-in environment to get started.
Built-in environment initialization steps:
- 1Open the app and navigate to "MCP → Environment Check"
- 2If you see Node.js, Python, or Git showing "Not Extracted" status, click the "Initialize Built-in Environment" button
- 3Wait for the extraction to complete (usually under a minute). A smoke test will run automatically after extraction
- 4All items showing green checkmarks means the environment is ready
Configure AI Model
Supported Providers
Tokeny comes with 10 built-in model channels, and also supports local deployment and custom channels:
In addition, Ollama (local deployment) and custom channels are supported (OpenAI / Anthropic protocol compatible, with custom Base URL). The model list is continuously updated with each release — refer to the app for the latest.
Configure API Key
- 1Click "AI Model" in the left navigation bar to enter the model configuration page
- 2Select the provider you want to use
- 3Enter your API Key in the corresponding provider section
- 4Click "Test Connection" to verify the Key is valid
API keys are stored in local configuration and used to authenticate requests to the configured model service. Verify the endpoint and keep keys out of chats, screenshots and public files.
Select & Switch Models
After configuring an API Key, you can select a default model from the model list. You can also switch between different providers and models during a conversation — new messages will use the newly selected model. Each session can have its own model selection, and multiple sessions within the same workspace don't interfere with each other.
Dual Protocol Switching
Some providers offer both OpenAI-compatible and Anthropic-compatible API protocols. You can switch between protocols with one click on the model configuration page, and the Base URL will update automatically.
Currently supported providers for dual protocol switching:
The Anthropic protocol supports more advanced thinking modes and tool-calling capabilities on some models. If you encounter tool-calling issues with the OpenAI protocol, try switching to the Anthropic protocol. The Base URL is automatically updated when you switch protocols — no manual changes needed.
Token Plan
Some providers offer Token Plan subscription billing (monthly/quota-based). When enabled, API calls for that provider are no longer billed per token. Tokeny automatically switches to the plan-specific API endpoint and sets cost tracking to zero.
Currently supported providers and applicable models:
| Provider | Applicable Models |
|---|---|
| GLM (Zhipu AI) | GLM-5.1, GLM-5-Turbo, GLM-4.7, GLM-4.5-Air |
| Kimi | Kimi K2.5 |
| MiniMax | M2.7 |
| Xiaomi MiMo | MiMo-V2-Pro, MiMo-V2-Omni |
To enable: go to the "AI Model" settings page and toggle on Token Plan in the corresponding provider section. Once enabled:
- Base URL automatically switches to the plan-specific endpoint; restored when disabled
- Models outside the plan are automatically disabled; restored when disabled
- Cost tracking for that provider shows zero (token usage is still recorded)
Token Plan requires you to purchase a subscription on the provider's platform first. Make sure your plan is active before enabling it, otherwise API calls may fail.
Recommended Models
Tokeny is an AI Agent application — the AI doesn't just "chat" but also "takes action": calling tools, reading/writing files, executing commands, multi-step planning, and decision-making. This requires models with strong Agent capabilities (function calling / tool use / instruction following), not just conversational ability.
Below are our recommendations based on real-world usage (pricing in CNY per million tokens):
High Performance
Top-tier Agent capabilities, ideal for complex multi-step tasks and professional scenarios
| Model | Context | Capabilities | Reference Pricing | Notes |
|---|---|---|---|---|
| Kimi K2.6 | — | 🧠🔧👁️ | — | Top-tier Agent capabilities, supports multimodal + thinking mode, excellent long-context performance |
| DeepSeek V4 | — | 🧠🔧 | — | Best balance of overall capability and price, the top daily-use choice |
| GLM-5.1 | — | 🧠🔧 | — | Zhipu AI latest flagship with reliable Agent capabilities |
| Qwen 3 Max | 131K | 🧠🔧 | 20 / 60 | Qwen flagship, powerful and stable tool calling, outstanding Chinese comprehension |
| Doubao Seed 2.0 Pro | 262K | 🧠🔧👁️ | 4 / 18 | ByteDance flagship, supports multimodal + thinking mode, 262K ultra-long context |
Best Value
Extremely low cost or free, excellent for everyday use and lightweight tasks
| Model | Context | Capabilities | Reference Pricing | Notes |
|---|---|---|---|---|
| GLM-4.7 Flash | 204K | 🧠🔧 | Free | Free with thinking mode + tool calling, the best choice on a budget |
| GLM-4.5 Flash | 131K | 🧠🔧 | Free | Free to use, stable and reliable Agent capabilities |
| GLM-4.6V Flash | 131K | 🧠🔧👁️ | Free | Free with vision understanding, can analyze images |
| Qwen 3.5 Flash | 1M | 🧠🔧👁️ | 0.2 / 2 | Million-token context window, multimodal, extremely low cost |
| DeepSeek V3.2 | 131K | 🧠🔧 | 2 / 8 | Best balance of Agent capability and price, top pick for beginners |
| Doubao Seed 2.0 Lite | 262K | 🧠🔧👁️ | 0.6 / 3.6 | 262K context + multimodal, exceptional value |
| Qwen 3 Coder Flash | 131K | 🧠🔧 | 1 / 4 | Specialized for coding tasks, excellent code generation and comprehension |
🧠 Thinking Mode 🔧 Tool Calling 👁️ Vision Pricing format: Input / Output (CNY per million tokens). Models and pricing may change as providers adjust them — refer to the in-app model list and each provider's official website.
If you're just getting started with Tokeny, we recommend starting with DeepSeek V3.2 — it excels at Agent tasks and is very affordable. For budget-conscious users, try GLM-4.7 Flash (completely free). For processing very long documents, choose Qwen 3.5 Flash (million-token context). For peak performance, go with Kimi K2.6 or MiniMax M2.7.
Not Recommended for Agent
The following types of models perform well in specific scenarios but are not suitable as primary models for Tokeny, as they have significant shortcomings in tool calling and Agent tasks:
DeepSeek-R1 (Reasoning Model)
Although extremely powerful in mathematical proofs and logical reasoning, it has weak function-calling capabilities. R1 is designed for deep thinking — it performs extensive reasoning before each tool call, leading to slow responses, high token consumption, and frequent tool-call formatting errors. For the same tasks, V3.2 far exceeds R1 in both speed and accuracy.
QwQ Series (Reasoning Model)
Similar issues to R1. QwQ focuses on reasoning and generates verbose "thinking processes" during tool calls, resulting in low actual execution efficiency. Even simple file operations may fail due to overthinking.
Kimi K1.5
This is a reasoning-only model that does not support function calling at all. It cannot use any tools in Tokeny and can only conduct plain text conversations.
Vision-Only Models (Qwen VL, GLM-4.5V, etc.)
Some vision models do not support tool calling. While they can understand images, they cannot help you perform file operations, run commands, or other Agent tasks.
Ultra-Long Context Models (Qwen Long, etc.)
Optimized for reading very long text, but typically do not support tool calling and cannot perform Agent tasks.
In short: Reasoning models are good at "thinking," Agent models are good at "doing." Tokeny needs models that can take action. Reasoning models (R1, QwQ, K1.5) are like someone with exceptional thinking ability but poor hands-on skills — they think deeply but can't execute well. Choose models with strong Agent capabilities like DeepSeek-V3.2 or Kimi K2.5 to get the most out of Tokeny.
Thinking Mode
Some recommended models (such as DeepSeek-V3.2, Kimi K2.5, Qwen 3.5 Plus, etc.) support a toggleable "Thinking Mode." When enabled, the model performs a round of reasoning before answering, which is ideal for complex questions requiring deep analysis. Unlike pure reasoning models like R1, these models retain full tool-calling capabilities in thinking mode and do not affect Agent task execution.
For custom models, you can manually declare whether they support thinking. The thinking mode toggle is remembered per workspace, so each workspace keeps its own setting.
We recommend enabling thinking mode temporarily when complex analysis is needed, and keeping it off for everyday use to get faster responses.
Chat Features
Basic Chat
Type your question or task description in the input box at the bottom of the main interface and press Enter to send. The AI will understand your intent based on context and provide a response. Multi-turn conversations are supported — the AI automatically remembers all context within the current session. You can also click the microphone button next to the input box for voice input.
Voice Input
Click the microphone button next to the input box and start speaking — the system automatically transcribes your speech into text with smart sentence segmentation. Chinese speech is polished before it lands in the input box: filler words are removed and punctuation is tidied up. Review the text, then send it.
Plan Mode
For multi-step or high-risk tasks, you can enable Plan Mode: the AI first presents an action plan, and only executes it step by step after your review and approval. You can pause execution at any time and approve each step individually. Ideal for complex tasks where you need tight control over the execution process.
Session Management
Sessions are organized by workspace. You can create multiple independent sessions within the same workspace — chat history is fully isolated, and each session can have its own model selection without affecting the others.
- The session switcher is located in the title bar — click to switch quickly
- Full-text search across conversation history: enter keywords to quickly find content in past sessions
- Unsent drafts and AI responses are saved automatically — nothing is lost even if the app quits unexpectedly
Files & Images
You can send files and images in conversations. Drag files into the input box or click the attachment button to select files. The AI can understand text files, code files, images, and many other formats, analyzing and answering based on file content.
Streaming Output
All AI responses use streaming output, so you can watch the generation process in real time. The AI's thinking process can be expanded or collapsed, displayed with a typewriter effect. Failed API calls are retried automatically, so network fluctuations won't interrupt your conversation. If you're not satisfied with the current response, you can click the "Stop" button to interrupt the output.
Message Queue
While the AI is executing a task (such as running commands, calling tools, or generating reports), you can continue typing new messages. These messages won't be lost — they automatically enter the message queue and wait for the AI to finish the current task before being processed in order.
- Messages sent while AI is busy will show a "Queued" tag
- After the AI completes its current task, it automatically picks up the next message from the queue
- Queued messages can be canceled at any time (click the cancel button next to the message)
- Multiple messages are processed in the order they were sent (first in, first out)
The message queue lets you use Tokeny like "batch instructions" — tell the AI all your ideas at once, and it will complete them in order. No need to wait for one task to finish before sending the next.
Interrupt & Priority
If the AI is executing a task you don't want, or you have a more urgent need, you can interrupt the current task at any time:
- Stop Generation: Click the "Stop" button, and the AI will immediately halt the current task. Any content already generated will be preserved in the conversation and won't be lost.
- Send Immediately (Priority): Queued messages support a "Send Immediately" action. Clicking it will interrupt the AI's current task and immediately start processing this priority message.
After interrupting a running task, it will not automatically resume. If you still need the AI to complete the interrupted work, you'll need to resend the instruction.
Skill System
What is a Skill
Skills are Tokeny's core capability extension mechanism. Each Skill is an independent professional module defined through a standardized SKILL.md file that specifies its capabilities, trigger conditions, and behavioral instructions. When a Skill is activated, its professional instructions are injected into the AI's prompt, giving the AI specialized expertise in that domain.
Built-in Skills
Tokeny ships with multiple professional built-in skills, ready to use out of the box. The commonly used ones are listed below:
| Skill | Trigger Command | Description |
|---|---|---|
| Web Search | /web-research | Search the internet for the latest information |
| Deep Research | /deep-research | Multi-round search, write research reports by sections |
| Code Review | /code-review | Code quality analysis and improvement suggestions |
| Visual Design | /canvas-design | Generate Canvas-based visual design drafts |
| Frontend Design | /frontend-design | Generate frontend page code |
| PPT Generation | /pptx | Generate presentations with native Office (.pptx) output |
| Word Document | /docx | Read and generate Word documents |
| Data Analysis | /data-analysis | Data processing, statistics, and visualization |
| Infographic Report | /infographic-report | Generate visual infographic HTML reports |
| Project Init | /init-project | Analyze workspace and generate project documentation |
| Save as Skill | /save-as-skill | Save the current workflow as a reusable Skill |
Manual & Auto Routing
Manual trigger: Type / in the input box to see all available skills and select one to trigger. For example, typing /deep-research current state of quantum computing will launch the deep research skill.
Auto routing: The AI automatically determines whether to activate a skill based on your conversation content. For example, when you say "help me search for the latest AI news," the system will automatically identify and activate the web search skill.
Skill Marketplace
The Tokeny Skill Marketplace features official and community skills. Visit tokeny-ai.com/skills to browse featured, popular, and latest sections, filter by category, or search; you can also browse the marketplace inside the client and install skills with one click.
On a skill's detail page, click "Install to Tokeny" to launch the client and install it in one step, or download the ZIP package and import it manually.
Official extension examples:
- Word Document Processing: Read and generate Word documents
- Excel Spreadsheet Processing: Read and generate Excel spreadsheets
- PDF Tools: PDF file parsing and processing
Custom Skills
Beyond built-in and marketplace skills, you can create your own Skills:
- Define capabilities with a SKILL.md file — supports file editing and hot reload, with changes taking effect immediately
- Install from the marketplace, a GitHub repository (including monorepo subpaths), or a local workspace
- Skills can have a Chinese display name, which is written into SKILL.md on installation and shown in the "Installed" list
The AI also suggests turning frequently used operations into skills — use /save-as-skill to save the current workflow as a reusable Skill.
Submit & Publish
Click "Submit" on the marketplace page to open the submission wizard:
- 1Import — provide a GitHub link, paste the full SKILL.md content, or upload a ZIP package
- 2Preview — the name, summary, and documentation are parsed automatically
- 3Confirm & submit — complete the category and tags; for the first release, upload the full ZIP package (up to 30 MB) and provide a version number
Submission limits are 5 per hour and 10 per day. Each submission goes through one review: once approved it is published immediately; if rejected, you can revise and resubmit. Manage all submissions and versions under "Profile → My Submissions" on the website.
Skill Management
Navigate to the "Skills" page from the left navigation bar to view all installed skills. Click any skill to see its details, including the SKILL.md source content. Here you can install, uninstall, or review the full prompt of third-party skills.
We recommend reviewing the SKILL.md content of third-party skills before installing to ensure they don't contain malicious instructions.
MCP Tool Extensions
What is MCP
MCP (Model Context Protocol) is an open tool extension protocol that allows the AI to call external services to accomplish specific tasks. Through MCP, Tokeny can connect to various third-party services such as database queries, email sending, browser automation, and more, greatly expanding the AI's practical capabilities.
Built-in Services
Tokeny includes the following built-in MCP services, ready to use without additional configuration:
- WebFetch: Retrieve web page content, supports HTML-to-Markdown conversion with built-in SSRF protection
- Web Search: Get the latest information from the internet via search engines
- Playwright Browser: Automated browser operations with three connection modes — launch a new instance, reuse your local browser Profile, or connect directly via CDP; tool connections are established asynchronously in the background, so a dropped service connection never stalls AI replies
- Email Service: Supports IMAP receiving and SMTP sending, configurable multiple email accounts for automated email processing
- Tokeny Connector Browser Extension: Takes over your already logged-in browser to auto-fill forms, scrape data, and submit, with screenshots captured throughout as evidence
MCP Marketplace
The official MCP Marketplace (tokeny-ai.com/mcp) features official and community MCP Servers. Browse by category or search; each detail page provides the install command and remote URL with one-click copy, and you can also launch the client to install with one click.
You are welcome to submit your own MCP Server — import from a GitHub repository or connect via a remote URL. The submission entry is the "Submit" button on the marketplace page.
Add Third-Party Services
- 1Go to "Settings → MCP Services"
- 2Click the "Add Service" button
- 3Choose the connection method: SSE (network URL), stdio (local command), or StreamableHTTP
- 4Enter the service URL or startup command
- 5After saving, the system automatically connects and loads the tool list
Service Management
On the MCP management page, you can view the status of all connected services (connecting/connected/disconnected), available tool lists, and runtime logs. You can manually reconnect, disable, or delete services. The system has a built-in automatic reconnection mechanism that restores connections after network recovery.
Built-in Tools
Tokeny includes 30+ built-in tools covering file operations, command execution, search, media generation, automation, and more. You can manage the enable/disable status of each tool on the "Tools" page within the app.
File Operations
The AI can perform file operations within your workspace. 10 operations are supported:
All file operations are confined to the workspace sandbox. The AI cannot access files outside the workspace. Delete operations require your confirmation.
Shell Command Execution
The AI can generate and execute Shell commands to accomplish tasks like installing dependencies, running scripts, and building projects. Real-time output and interactive commands are supported. An approval dialog appears before each command execution, giving you the following options:
- Approve: Approve only this specific command. After execution, if the AI needs to run another command, a new approval dialog will appear. This is the safest approach, recommended for everyday use.
- Auto-execute: Once enabled, all subsequent Shell commands generated by the AI in the current session will execute automatically without individual approval dialogs. Suitable when you trust the current task and need to run many commands consecutively (e.g., project initialization, bulk dependency installation).
- Reject: Cancel execution of the current command. The AI will adjust its approach based on your feedback.
Important: Shell commands are NOT restricted by the workspace sandbox. Unlike file operation tools, Shell commands can access any file and directory on your entire computer and execute any system command (such as installing software, modifying system configurations, accessing the network, etc.). Always carefully read the commands the AI generates. If you don't understand a command, ask the AI to explain it first, or simply reject it.
Search & Locate
The AI can quickly locate files and content within the workspace:
- grep — Content search, supports regular expressions, file type filtering, and recursive search
- glob — Path matching, quickly locate files by filename patterns
User Interaction & Planning
The AI proactively collaborates with you when executing complex tasks:
- Ask User — Proactively asks you questions when additional information is needed
- Task Planning — Breaks complex tasks into step-by-step checklists with real-time progress updates
- Progress Reports — Reports current progress during long-running tasks
- File Preview — Preview generated files directly within the app
Media Generation
The AI can call configured media models to generate images and videos. You can specify separate models for image generation and video generation in the "AI Model" settings (e.g., SiliconFlow, Doubao, etc.).
Multi-Agent Collaboration
Tokeny supports multiple forms of multi-agent collaboration:
- Group Chat Collaboration — Multiple agents collaborate in the same conversation, handing off via @ mentions to complete tasks together
- Sub-task Delegation — Delegate sub-tasks to independent Agent instances for isolated execution, avoiding context interference; results are reported back to the main task upon completion
- Preset Agents — 25 built-in roles (Tech Lead, Deep Researcher, Meeting Minutes, Bookkeeping Assistant, and more), ready to use out of the box
- Custom Agents — Create your own agent with a single natural-language description
The AI can also create and manage Cron scheduled tasks — see the "Scheduled Tasks" chapter for details.
Management & Extensions
The AI can manage Skills and MCP services directly within the conversation, without needing to navigate to the settings page:
- Skill Management — List, install, uninstall Skills (supports installation from URL, marketplace, or workspace)
- MCP Management — List, add, remove, start/stop MCP services and query available tools
- Security Audit — Perform AI semantic security analysis on high-risk commands
- Terminal Preference — Specify your preferred command-line tool for smarter detection at runtime
Safety & Approval
Approval Workflow
When the AI needs to perform high-risk operations (such as running Shell commands or deleting files), the system automatically pauses and displays an approval dialog. You have three options:
- Approve: Confirm and execute the original command
- Edit & Execute: Modify the command content before execution
- Reject: Cancel execution; the AI will adjust its approach based on your feedback
Dual-Layer Security Review
Tokeny employs a dual-layer security review architecture to ensure thorough evaluation of high-risk operations:
- Layer 1: Rapid Risk Identification: The system automatically assesses risk for each command, identifies dangerous operation patterns, and labels risk levels with extremely fast response.
- Layer 2: AI Deep Analysis: For commands flagged as high-risk, additional AI semantic analysis is performed to generate a risk summary and detailed explanation, displayed in the approval dialog for your reference.
Review results are cached, so identical commands won't be analyzed repeatedly. The review scope includes Shell commands, Skill activation, and Skill installation. You can enable or disable the security review feature in "Settings."
Permission Control
Tokeny provides a three-tier permission control system, configured independently per workspace to meet different security needs:
| Mode | Description | Best For |
|---|---|---|
| Default | All high-risk operations (Shell commands, file deletion, etc.) require manual approval | Everyday use, security-first |
| Full Access | Skip file operation approvals, but retain Shell command approvals | Development scenarios with frequent file operations |
| Autopilot | All operations execute automatically without approval | Trusted batch automation tasks |
"Autopilot" mode allows the AI to execute all operations automatically, including Shell commands and file deletion. Only use this mode when you fully trust the current task. We recommend combining it with workspace sandbox isolation.
In addition, the system can detect approval deadlocks and proactively alert you, so tasks never get stuck in repeated confirmation loops.
File Protection
The file system security validator provides three-stage path verification: path normalization, path traversal attack detection, and symlink target verification. All file operations are restricted to the workspace sandbox, ensuring the AI cannot access or modify critical system files.
Workspace
File Management
The workspace is a shared file directory between you and the AI. You can browse the file tree, create folders, and upload files from the right panel. Files generated by the AI (such as research reports, code files, and PPTs) are all saved in the workspace. File management also includes the following capabilities:
- The file tree watches external changes in real time and refreshes automatically
- Right-click context menu operations and inline renaming are supported
- External editors can be detected and launched to open files
File Preview
The workspace includes a built-in multi-format file previewer supporting the following formats:
- Markdown (.md): Rendered rich-text display
- Word Documents (.docx): Full document preview
- PPT Presentations: Reveal.js slideshow preview and playback
- HTML Projects: Embedded browser rendering with live preview for multi-file projects
- Code Files: Syntax-highlighted display
- Image Files: Preview for common image formats
- Video Files: Built-in player preview
Report Export
Reports and documents in the workspace can be exported as PDF or Markdown formats. Click the export button on the file preview interface and select the target format. PDF export uses a built-in rendering engine to ensure styles match the preview.
Smart Memory
Automatic Memory Extraction
After a conversation ends, Tokeny asynchronously extracts your preferences and key facts. The memory system uses a dual-layer architecture with structured categorization, so the AI understands you better over time:
- Dual-Layer Memory Architecture: Global memories take effect across workspaces, while workspace memories apply only to the current project.
- Seven Structured Categories: Memories are archived into seven categories: preferences, facts, instructions, events, profiles, relationships, and goals.
- Three-Stage Smart Injection: In your next conversation, relevant memories enter the AI context through a three-stage smart injection mechanism.
- Full-Text Search & Conflict Merging: Memories support full-text search, and conflicting memories are merged automatically.
Memory can be stored locally. When extraction or organization uses an online model, relevant context may be sent to the configured model service.
Memory Maintenance
A background maintenance system periodically organizes your memories to keep the memory store healthy:
- Clean up expired memories
- Decay memories that have been inactive for a long time
- Merge fragmented memories
- Detect and flag contradictory memories
You can assign a dedicated model to the memory system (for example, a cheaper model to handle memory extraction and maintenance) without affecting your main conversation model.
Memory Management
Navigate to the "Memory" page from the left navigation bar to view, edit, or delete saved memory entries. Memories are displayed as structured cards with category filtering and full-text search. You can manually add important personal preferences or remove inaccurate memories.
Scheduled Tasks
Create a Task
You can create automatically executing tasks in "Settings → Scheduled Tasks." Each task includes a natural language instruction and an execution schedule. When the specified time arrives, the system automatically creates a new session and executes the task instruction.
Cron Expressions
Scheduled tasks use Cron expressions to define execution times. Common examples:
| Expression | Meaning |
|---|---|
0 9 * * * | Every day at 9:00 AM |
0 9 * * 1-5 | Weekdays at 9:00 AM |
0 */2 * * * | Every 2 hours |
0 9 1 * * | 1st of every month at 9:00 AM |
Task Management
Scheduled tasks have a dedicated overview page that brings together the status and last run time of every task. Task results are presented as notification cards, so you can follow the execution in real time. You can enable/disable, edit, and delete tasks at any time.
Smart Assets
What Are Smart Assets
Reports, presentations, notes, images and other deliverables produced by the AI during conversations are automatically collected into the local Smart Assets library (Labs) for unified management — no longer scattered across different places.
Browsing & Management
The asset library supports tag-cloud filtering, preview popups, and full create/read/update/delete operations. With built-in full-text search, you can locate any past deliverable locally in seconds.
Referencing in Tasks
During conversations, you can reference content from the asset library as source material, letting the AI build on your existing work to keep creating.
IM Integration
What is IM Integration
IM integration allows you to chat with Tokeny directly through enterprise instant messaging platforms (such as Feishu/Lark). Once configured, messages sent in the IM are automatically received and processed by Tokeny, with responses sent back to the IM chat window. You can use AI capabilities remotely without opening the desktop application.
IM integration uses a zero-LLM-gateway design — message routing is handled entirely by the rule engine without consuming additional AI model calls, ensuring fast response times and cost control.
Supported Platforms
Currently supported IM platforms:
- Feishu/Lark — Full support: direct execution mode with no repeated confirmation cards; the tool system covers two modules — messaging/group chat and platform capabilities — letting you work with Bitable, Docs, Calendar, Contacts, Drive, and Wiki; MCP external tools can also be invoked right from the IM
- WeCom (WeChat Work) — Interface reserved, coming soon
- DingTalk — Interface reserved, coming soon
Configuration & Usage
Using Feishu/Lark as an example, the setup steps are:
- 1Create a custom app (bot type) in the Feishu/Lark developer console
- 2Obtain the App ID and App Secret
- 3Navigate to the "IM" page in Tokeny's left navigation bar and enter the credentials
- 4After enabling the connection, Tokeny will automatically receive Feishu messages via long-polling
- 5In Feishu, @ your bot or send a direct message to interact with Tokeny
Once connected, you can use all of Tokeny's core features directly in the IM: chat, trigger Skills, execute tools, etc. IM sessions and desktop app sessions are independent, each with their own context.
IM integration requires your computer to remain on and Tokeny to keep running. If the application is closed, messages from the IM side cannot be processed.
Theme & Settings
Theme Switching
Tokeny supports three theme modes: Dark, Light, and Follow System. Click the theme button at the bottom of the left navigation bar to cycle through them. When "Follow System" is selected, the app automatically matches your operating system's dark/light setting. Theme preferences are saved automatically.
Mini Mode
Mini Mode is a compact window form that keeps only the core chat interface — perfect for pinning to a corner of your desktop for quick questions anytime. You can switch back to the full window at any time.
Data Storage
The desktop app can store the following in its local database or workspace directories. Accounts, online models and enabled services may also involve server processing:
- Conversation history and message records
- Application settings and preferences
- Workspace files and directories
- Persistent memory data
- API Keys (encrypted storage)
- Scheduled task configurations and execution records
Uninstall and cleanup behavior depends on the installation. Deleting local files does not replace server-side account data requests; see the privacy policy.
Token Usage Statistics
In the "Settings" panel, you can view detailed Token usage statistics to help you understand and control AI usage costs:
- View input/output Token consumption per session
- Breakdown by model and provider
- Real-time display of current conversation Token cost
- Sub-task and background task usage also tracked
The desktop app can retain local task usage. Online providers and built-in channels may also retain billing and usage records. Clearing local history does not remove server-side billing records.
The Settings page is organized into tabs by topic (Models, Tools, Scheduled Tasks, and more), keeping information clearly structured.
Keyboard Shortcuts
| Shortcut | Description |
|---|---|
| Enter | Send message |
| Shift + Enter | New line |
| / + Skill name | Manually trigger a Skill |
| Ctrl/Cmd + N | New session |
| Ctrl/Cmd + , | Open settings |
| Esc | Stop AI generation |
Haven't installed yet? Download now and try it out
Download Now