# Agent Computer
Source: https://docs.tess.im/en/agent-computer
Tess Agent Computer is an autonomous General AI Agent that moves beyond standard AI conversations. Rather than handling prompts individually, Tess Agent Computer takes on complex, multi-step work and carries it through from start to finish on your behalf.
Tell Tess what you need, walk away, and return to completed work — polished documents, organized files, consolidated research, spreadsheets with fully working formulas, dashboards and more.
The Agent Computer can be accessed directly within the Tess chat interface by switching the applicable function from Chat Mode to Agent Mode.
### What is Tess Agent Computer?
Tess Agent Computer changes the way you work with AI. While standard conversations require your presence at every stage, Tess Agent works on its own — planning, executing, and delivering results without you having to monitor each action.
This level of autonomous execution is not available in regular conversations outside of Tess.
### Key capabilities
Tess Agent splits complex work into smaller subtasks and manages parallel workstreams to get them done efficiently. Each step is assigned to the model best equipped for that kind of work.
Produce ready-to-use deliverables — Excel spreadsheets with working formulas, PowerPoint presentations, formatted documents, dashboards, custom tools and more — with no extra manual effort required.
Tackle complex work over extended periods without being cut off by session timeouts or context limitations.
Set up and save tasks to run on-demand or on a recurring schedule of your choice — daily, weekly, or custom.
Tess Agent keeps going even if you close your tab, lose your connection, or shut down your device. Autopilot guarantees up to 50 minutes of uninterrupted execution, requiring no supervision.
### How Tess Agent runs your tasks
Code runs securely inside an isolated environment, but Tess is capable of making real changes to your files and systems.
Once you kick off a task in Agent Computer, Tess:
Reviews your request and builds an execution plan.
1. Breaks the work into subtasks whenever needed, keeping things efficient.
2. Runs everything inside a secure, isolated virtual machine (VM).
3. Manages multiple workstreams simultaneously, where it makes sense to do so.
4. Delivers the final outputs straight to your file system.
You stay fully informed of what Tess is planning and doing at every stage. You can step in to provide guidance whenever it matters — or simply let Tess handle everything independently.
At certain points, Tess Agent may check in with a few questions to make sure the final output is exactly what you had in mind.
# Agent Types
Source: https://docs.tess.im/en/agent-types
Think of an Agent as a personalized assistant, ready to perform tasks based on your needs. It is a smart, contextualized AI configuration that plays the role of a team member (AI Workforce).
You define the instructions (the prompt), provide the necessary knowledge (such as documents and spreadsheets), and select the tools it can use. From there, the Agent can interact with various sources — such as the web, PDFs, and other AI modules — to deliver a complete and personalized result.
In Tess AI, anyone can create agents in just a few minutes, with no programming knowledge required (it is fully no-code). This makes Agents your greatest allies in automating, standardizing, and personalizing tasks.
> Practical example:
>
> *Instead of starting from scratch every time you need to create LinkedIn posts, you can create an Agent specialized in that task, already configured with your instructions. It will be set up with best practices for social media writing, your tone of voice, and the desired style — speeding up the process and ensuring the quality and consistency of your content.*
## **Agent Types in Tess**
You can create different types of Agents in our Agent Studio:
This is the most common and versatile type of Agent. Perfect for dynamic and interactive demands, where the user can continue the conversation with the Agent after the first response in order to refine the content. Chat Agents enable a fluid conversation with the AI, allowing you to refine and adjust the result with each interaction.
*Applicable for: Customer service demands, brainstorming sessions, information research, general analyses, and any task that benefits from a conversational interaction.*
Ideal for helping with the creation of any written content that does not require continuous interaction with the LLM. They receive your instructions and return ready-made texts, ensuring agility and a high quality standard.
*Applicable for: Creating reports, emails, transcriptions, and summaries.*
Allow you to generate images with a consistent visual style. You can create Agents that follow your brand's visual identity, generate logos, or create specific visual elements for your campaigns.
*Applicable for: Creating standardized images with your visual identity, futuristic visuals, linear logos, illustrations for posts, or any visual element that needs to follow a specific standard.*
Automate the creation of audiovisual content based on predefined parameters. They facilitate the large-scale production of videos for various purposes, maintaining consistency and quality.
*Applicable for: Producing institutional videos, tutorials, social media clips, and presentations.*
## **Main Advantages of Using an Agent**
Adopting Tess Agents in your daily routine brings immediate benefits:
* **Time savings:** Eliminate the need to configure the AI from scratch. Activate a ready-made Agent and streamline your process intelligently.
* **Standardization:** Maintain the format, style, and visual identity of your communication, generating consistent results across all deliveries.
* **Personalization:** Adapt Agents to your specific needs and get tailor-made results for each context.
* **Performance gains:** Once trained, Agents become specialists in that subject and perform better than untrained AI.
\
Explore this possibility and, for any questions, contact our team at: [support@tess.im](mailto:support@tess.im).
# Auto Mode
Source: https://docs.tess.im/en/auto-mode
Let Tess automatically choose the best AI model for each conversation, without needing to be an LLM expert.
### **What is Auto Mode in Tess Chat?**
It's the technology that allows Tess to choose which LLM to use to respond to your request at the time of the query. Instead of having to manually decide which model to use for each chat, Tess evaluates the type of message and selects the most suitable model at that moment.
This is made possible through a sophisticated routing algorithm developed by Tess to choose the best model according to several variables: response quality (performance), speed, cost, and the complexity of the model and request. This is the safest option for those who want good responses without needing to understand models.
### **Why does it matter?**
* Ideal for non-specialists: you don't need to know technical details about AI.
* Strong overall performance: Tess chooses an appropriate model for most cases.
* Collaboration between models: with each query, a new model can be called and collaborate with the previous model's response.
### **Quick start**
Start a new conversation or reopen one from your history
If it's not already selected, find the LLMs control and enable the "Auto" option
Send your typical messages (support, sales, internal). Observe the quality and response time.
If in any specific case you want to test another model, temporarily disable Auto, manually select any LLM from the list, and compare the results.
Switching between models is the key to Multi-LLM usage in a single chat!
**Tips:**
* Use Auto as the default for teams that aren't familiar with AI.
* Choose a specific LLM when there's a clear reason to do so, stepping out of Auto Mode due to quality, cost, or compliance requirements, for example.
* Test periodically: compare responses with Auto on and with a specific AI model to ensure the balance continues to make sense for your context.
# Tess Autopilot
Source: https://docs.tess.im/en/autopilot
It’s very common that every professional in their day-to-day needs to deal with complex work that even AI takes a bit longer to deliver: extensive research, analyzing a large document, generating a complete report.
Tess Autopilot was created to make this kind of task easier, without you having to keep following the AI’s work, or even keep your computer on or the tab open. Now you can request the work, give the instructions, and simply let Tess work and finish the job for you. During that time, you can have a coffee, sleep, or dedicate yourself to other work.
Tess Autopilot keeps the AI running in the background, with high resilience to connection drops and app closures, so you no longer need to “watch over” task execution.
### **Main pillars of Tess Autopilot**
Tess Autopilot transforms the experience of "waiting for AI to respond" into something much more robust, closer to a cloud processing service: you request, go about your life, and only return to receive the result. Your agents work autonomously even while you rest.
This is the new operating mode of Tess chat that guarantees:
“Background execution” means the AI no longer depends on your window or app staying open all the time.
Tess Autopilot was designed to support long tasks. Today, it allows up to 50 minutes of uninterrupted work in a single chat flow.
With Autopilot, Tools start working reliably for up to 40 minutes same execution.
Automatic reconnection in case of fluctuation or a 4G/Wi‑Fi drop.
Beyond the text itself, Tess Autopilot also improves stability when using Tools (chat tools), such as Internet, Deep Analysis, Manage Files, Music, Speech, Avatar, Video, etc.
Network problems shouldn't interrupt your workflow. With Tess Autopilot, if the 4G or Wi-Fi signal fluctuates or drops, the system attempts to reconnect automatically.
Of course, as long as the task is still within the execution window (up to 50 minutes of chat and 40 minutes of Tools), processing continues on the server. When the connection is restored, you see the result or progress directly in the chat, without having to start over.
This is especially valuable for those who work on the go (coworking, cafes, airports); in locations with unstable Wi-Fi or using 4G/5G as their primary connection.
### **Perfect use cases for Tess Autopilot**
“Do detailed research on AI trends in the financial sector, bringing references, examples of companies, and regulatory risks.”
“Build a comparative report among the main competitors X, Y, and Z, with a table of pros and cons.”
Long contracts, dossiers, technical reports, and extensive articles.
Large spreadsheets with many records (sales, churn, NPS, etc.).
Here, Autopilot ensures that:
• the chat and Deep Analysis have time to read, process, and calculate everything;
• you don’t lose the execution if you need to close the app or if the internet fluctuates.
Generating lengthy presentations.
Creating manuals, playbooks, and complex service flows.
Assembling documents with multiple sections and processed attachments.
Generating videos, audios, avatars, music tracks, and combinations among these tools.
• Tasks that chain multiple Tools and require more processing time.
With Autopilot, these chains have a much higher chance of reaching the end without interruptions.
Tess Autopilot is the natural evolution for those who use AI as a serious part of their work: AI stops being something you need to “monitor” and becomes a true 24/7 assistant, that keeps working with you — and for you — even when the connection fluctuates, the app closes, or your focus needs to go somewhere else.
# Avatar
Source: https://docs.tess.im/en/avatar
Tess AI’s Avatar tool lets you create videos with a digital presenter who “speaks” a script you provide, with lip sync. This enables professional-looking content without a camera, studio, in-person recording, or traditional editing — ideal for scale and standardization.
In this process, the AI animates the avatar, generates or uses the audio, syncs lip movements with speech, and renders the final video for download.
### **Models available in Tess**
To enable it, just find the Avatar option in the tools button. There you’ll find models like HeyGen, Omni Human, and Wan.
Each option tends to have different configuration and performance (avatar style, realism, expressiveness, lip sync quality, language/voice options, etc.).
\
It is focused on creating avatar videos mainly for commercial use.
Strengths: Very easy and fast: interface, templates, teleprompter, subtitles, translations/dubbing, ready-made flows. Consistent quality for “presenter talking to the camera”.
Typical limitations: Less “creative freedom” in the model, since you operate within what the platform offers. Less flexible for complex scenes (full body in motion, interaction with the environment, long acting).
You stay “inside the editor” and the platform’s options (less low-level control).
**When it makes the most sense:** marketing videos, onboarding, tutorials, internal updates, etc.
See more in chat: [Access conversation](https://tess.im/published-chats/d83fe0c4-7aa2-4823-b348-e57bccdfbe58)
\
Its focus is movement/expression quality and generalization to different identities/poses
* It can accept: audio + reference image/video → animation/lipsync
* Or text/conditions + reference → generated/animated human
Strengths: Potentially better realism in expressions, face consistency, and movement (depending on the version). More freedom if you need to move beyond the “standard presenter” and into acting/movement/styles.
Limitations: Higher chance of “variance” and need for adjustments (seed, parameters, post-processing).
**When it makes the most sense:** technical team, R\&D, or when you need visual control beyond the corporate standard.
See more in chat: [Access conversation](https://tess.im/published-chats/36fc7b90-48c7-4078-8bfc-db1a482309ef)
\
“Wan” has a family of models; in this tool we provide the sync and animation one.
* Image → video (animate an image)
* Sometimes: audio + image → talking head
Strengths: Very good for creating scenes and videos based on images and also from scratch.
Limitations: In some cases and languages, audio-to-image sync may not keep the mouth perfect. Or even identity consistency (the face staying the same throughout the video) can be harder than on platforms focused on avatars.
**When it makes the most sense:** creating full/stylized videos, more “cinematic” ads, scenes with environments; or when the avatar is just part of the video.
See more in chat: [Access conversation](https://tess.im/published-chats/5544bc98-1875-4249-8644-ddd93f1125a5)
**When to use (ideal cases)**
* onboarding modules
* product and process trainings
* internal policies and standardized announcements
* short announcement videos
* feature presentations
* welcome messages and “product tours” with consistent identity
* team/project updates
* leadership communications (with standardization and speed)
* short educational videos (Reels/TikTok)
* weekly series with the same visual identity
Tip:
If you want, you can combine Avatar + Speech (Narration) for full control, especially if you want maximum voice consistency (tone, rhythm, timbre).
**How to write scripts that sound natural in an avatar**
* Write “to be spoken”, not like an article
* Use short, direct sentences
* Avoid long paragraphs
* Add natural pauses with punctuation
* For acronyms, prefer writing them out in full the first time (e.g., “Customer Success” before “CS”)
* If there are technical terms, include one sentence of context to reduce “robotic reading”
**Credits usage and generation time**
Avatar videos tend to consume more credits than text and simple narration, because they involve rendering. They can also take a bit longer to be ready, especially for long videos or higher-quality settings.
If you need anything, you can reach our support team at: [support@tess.im](mailto:support@tess.im).
# Background Models
Source: https://docs.tess.im/en/background-models
Background Models are specialized LLMs that work behind the scenes in Tess, executing specific functions that go beyond the main response in the chat. They allow more control, better performance, and cost optimization, since each function can use a different model, chosen according to the need.
### **What is it?**
In addition to the main model that responds in the chat, Tess uses 8 auxiliary models responsible for tasks such as:
* Extraction and organization of memories
* Task routing between agents
* Coordination of multi-agent executions
* Intelligent search
* Error explanation
These models operate transparently for the end user and can be configured by Owners or Administrators to balance quality vs. cost.
### **How to use it?**
1. Access the workspace settings
2. Go to the Background LLMs section
3. View the available functions (Memory, Autopilot, Workflow)
4. For each function:
* Select the desired model
* Adjust according to quality or cost needs
5. Save the settings and you're done — the models will start operating automatically in the background\\
### Deeper explanation
Background Models are organized into three main blocks:
1. **Extraction Model**\
Reads conversations and identifies relevant facts about the user. In this case, the model runs automatically after each conversation. More capable and advanced models extract richer and more accurate facts.
2. **Collective Digest Model**\
Runs daily and synthesizes what the team learned during the day. Transforms dozens of individual facts into a readable summary for managers. Uses only facts authorized to be shared.
3. **Consolidation Model**\
Keeps memory clean over time. Merges duplicate or fragmented facts into a single, more complete fact. Prevents noise accumulation in memory.
1. **Automatic Routing Model**\
When a task arrives without a defined destination, it decides which AI Employee is most suitable to execute it.
2. **Team Coordinator Model**\
In multi-agent executions, it decides the sequence and distribution of work — who acts first, who reviews, who delivers.
3. **Automatic Search Model**\
Before each response with active search, it analyzes the question and decides whether it is necessary to search the internet — and which terms to search for.
4. **Hiring Model (Omnibar/hire)**\
When you use /hire to create an AI Employee, it creates the agent profile and generates detailed work instructions.
\
**Error Summary Model**\
When a workflow fails, this model translates the technical error message into simple and understandable language for the user — explaining what happened and what can be done.
**Best practices**
* Use stronger models only where there is real gain
* Keep lightweight models for repetitive tasks (e.g.: consolidation)
* Review settings as team usage evolves
* Test changes in controlled scenarios before scaling
* Combine with the use of Memory to improve consistency
### **Important notes**
* Background Models consume credits, even when operating invisibly
* Each function runs at different times (e.g.: real-time, post-chat, daily)
* The choice of model directly impacts:
* Quality of automations
* Total workspace cost
* Available only in plans with support for Background LLMs
Background Models allow Tess to operate with multiple specialized intelligences at the same time. This increases response quality, improves automation, and provides fine control over cost — all without complexity for the end user.
# Product Updates
Source: https://docs.tess.im/en/changelog
The latest Tess releases — new features, improvements, and bug fixes.
## Gemini 3.8 Flash and a refreshed website
### New features
* **Gemini 3.8 Flash.** Google's most capable Flash model is now available in Tess — stronger long-horizon coding, autonomous agents, and multi-step reasoning, at the same introductory price as 3.7 Flash. Select it in chat and in your agents.
### Improvements
* **A redesigned Tess website.** Home, pricing, and the blog have a new layout aligned with the Tess brand, so it's easier to explore the product, compare plans, and read stories.
## Chat reliability, knowledge bases, and workspace files
### Fixes
* **Team settings and user restrictions in Portuguese and Spanish.** Modals for team configuration and user restrictions now show translated text instead of falling back to English when your account is set to Portuguese or Spanish.
* **Credits settle reliably during busy runs.** Concurrent agent runs could occasionally fail without recording correctly; billing and execution records are now processed in a safer order so your runs complete more reliably.
* **Shared agents can use their knowledge base files.** When a teammate runs an agent with attached documents, Tess can now open those files instead of blocking access and creating duplicate copies.
* **Chats with tools stop hanging for many minutes.** Conversations using Claude models with tools enabled now finish their final response instead of retrying for 10+ minutes after tool calls are complete.
* **Agent runs no longer duplicate identical files.** If an agent saves content you already have under a new name, Tess reuses your existing file instead of cluttering your file list with copies.
## Attachment-heavy chats and clearer upload errors
### Fixes
* **Heavy conversations with attachments keep working.** When your chat includes large documents or files, Tess now counts attachment size when deciding how much history to send, so long threads drop older turns instead of failing with a misleading provider error.
### Improvements
* **Upload errors show on the attachment.** When a file fails to upload, the reason appears on the attachment chip instead of a disappearing toast.
## Public Pages labels, Auto chat routing, and account privacy
### Improvements
* **Public Pages replaces Artifacts in Settings.** The Workspace section and permission labels now say Public Pages so they match your published sites and are easier to distinguish from other artifact features in the product.
### Fixes
* **Auto mode picks the right model again.** When you use Auto in chat, the routing step now uses its own configured model instead of failing silently or showing a generic provider error.
* **Less sensitive data on signed-in pages.** Authenticated pages now load only the profile fields the interface needs, reducing exposure of account credentials in the browser.
## Chat streaming, API billing, and connector attachments
### Fixes
* **Chat streams recover instead of hanging for nearly an hour.** Long-running agent replies now surface a clear timeout when the stream goes quiet, instead of staying on working until the hard limit discards your answer.
* **Incomplete streamed answers no longer disappear.** A malformed line in the response stream no longer aborts the entire reply with a fake provider error.
* **API conversation history stops creating phantom executions.** When you send prior messages through the API, history is stored as context instead of fake in-progress runs that later trigger incorrect refunds.
* **Email connector attachments go through reliably.** Files attached when sending email through a connector are uploaded to the connector storage instead of failing on temporary download links.
## Clearer model restriction messages
### Improvements
* **Honest messages when a model is restricted.** When your team policy blocks a model, you now see a clear explanation instead of a generic provider error, with a Solve it for me action when you can switch to an allowed model.
## Chat model restrictions
### Fixes
* **Clear explanation when an agent uses a model you cannot access.** If an agent is pinned to a model outside your team policy, chat tells you the agent is restricted instead of blaming the AI provider.
* **Honest guidance when your selected model is blocked.** When team policy blocks the model in the selector, you see which model was denied and can use **Solve it for me** to switch to an allowed model and resend your message—without a misleading temporary-error message or a Retry button that will never work.
## PDF billing, models, and agent tools
### Improvements
* **PDF processing billed per processed page.** The 20-credit fee for standard PDF processing is gone. You now pay per processed page, with the same rate for regular and OCR PDFs. Through September 1, 2026, each page costs 1 credit — about 40% off the usual 1.68 per page.
* **Transparent billing when agents use tools in chat.** Credit usage now reflects the tokens your agents consume during tool-calling loops, with consistent plan-specific billing instead of an invisible global switch that did not match real usage.
### Fixes
* **Your selected model is the one that runs.** Choosing GPT 5.4 nano in chat or API runs now uses that exact model instead of silently substituting a different one.
## API clarity, chat reliability, and file billing
### Improvements
* **Clearer API tools-policy rejection messages.** When an API request conflicts with an agent's tool settings, the error explains which tools are allowed and why, including Agent Mode restrictions, instead of a generic validation message.
* **More time for the first response on long reasoning turns.** Chat streams now wait up to 15 minutes before timing out on the first token, giving reasoning models and large contexts enough time to start responding.
### Fixes
* **Gemini agents with tools run reliably.** Chat with Gemini and tool-enabled agents no longer fails when a connected tool exposes array parameters without a detailed schema.
* **Vision images work across more model providers.** Image attachments in chat are sent inline to providers that cannot fetch signed download links, so vision turns complete instead of failing silently.
* **Clearer timeout errors when tools or workflows run long.** When a provider or nested tool takes too long, you see a specific timeout message instead of a generic temporary-issue error.
* **Chat stops retrying on errors it cannot fix.** Streams no longer keep reconnecting when credits are insufficient, access is denied, or the session expired; the UI shows the right error immediately.
* **File uploads and processing charge once.** Parallel uploads of the same file and mixed sync or async processing no longer create duplicate records or credit charges.
* **Failed file processing refunds credits reliably.** When indexing or attachment processing fails, credits are refunded exactly once instead of being lost or refunded multiple times.
## Large file attachments in chat
### Improvements
* **Large documents get more time to extract and index.** Processing limits now scale with document size, and indexing can resume from where it left off if a run is interrupted.
### Fixes
* **Large chat attachments are read correctly.** Documents whose extracted text is too large to load inline are now handled end to end, so you can ask questions about big files instead of the assistant behaving as if the attachment were empty.
* **Attachments stay visible while still processing.** The chat no longer marks files as failed on a short timer when indexing is still running in the background.
* **Failed attachments no longer vanish after reload.** Files that were still processing are kept in the conversation instead of disappearing when you refresh the page.
## Chat reliability, file downloads, and model execution
### Fixes
* **Clearer remote support request wording.** The remote support modal no longer references internal company names and instead uses the same team-facing language as other support options.
* **Chat file downloads and previews stay available.** Downloading or opening files in a conversation still works after you have been reading the chat for a while, instead of failing with an expired link error.
* **Chat turns recover when a stream closes silently.** If a live response stream ends without a final message, the conversation can reconnect or show a clear error instead of leaving the turn spinning indefinitely.
* **Grouped model variants run without errors.** Agents using grouped model options no longer fail at send time because of UI-only settings reaching the model provider.
## AI Studio, connectors, knowledge base, and chat performance
### Improvements
* **Model information loads on hover in selectors.** Model dropdowns no longer preload every model card into the page, so agents with long model lists open faster while the same details still appear when you hover an option.
### Fixes
* **Agent editor Save button no longer gets stuck.** Saving changes in AI Studio reliably re-enables the Save button after the form loads, instead of leaving it disabled with no error when model tooltip scripts fail to initialize.
* **Granola connector works end-to-end.** You can connect Granola and ask the assistant to list meetings or read transcripts without connector unavailable errors or failed sign-in flows.
* **Dense PDFs in knowledge base embed reliably.** PDFs with very text-heavy pages are split and processed in smaller batches, so large documents index successfully instead of failing during embedding.
## Chat, API, Cowork, and connectors
### New features
* **API execute requests honor agent tool policies.** Your API calls now respect the same tool locks, no-tools mode, and user-decision settings configured for each agent in the product, with clear errors when a request tries to bypass creator restrictions.
* **Confirmation before generating many images in one turn.** After five successful images in a single chat turn, you choose whether to generate more, stop, or silence future prompts, so unexpected image batches do not keep running without your consent.
### Improvements
* **Faster chat page loading.** The chat page ships less hidden markup when it loads, so heavy workspaces open noticeably sooner without changing how model information appears in the selector.
* **Larger work instructions in Cowork Autopilot setup.** You can save custom operating instructions up to 100,000 characters when creating or editing digital employees, with a clear counter and deploy protection if you exceed the limit.
### Fixes
* **Speech audio previews play in chat.** Generated MP3 audio from speech tools now shows an inline player in current and past messages, so you can listen and download voice output directly in the conversation.
* **Connector limit errors no longer look like expired connections.** When a workspace connector limit disables an app for the current chat, you see a neutral limit message instead of a false connection-expired prompt and unnecessary reconnect flow.
## Shared chats, file uploads, Salesforce connectors, and video generation
### Fixes
* **Cloning a shared chat opens a working conversation.** When you clone a chat whose original agent you cannot access, you land on the default chat agent instead of an error page, so you can keep reading and replying.
* **Salesforce document bundles download correctly.** Agents that collect Salesforce files into a ZIP return the actual documents instead of empty archives or manual download links only.
* **Managers can read files they upload in chat.** Workspace document managers who upload a file that already exists in the workspace get their own copy and can open it in conversation instead of silently referencing another member's private file.
* **Unavailable video model removed from the generator.** A retired Leonardo Motion option is no longer listed, so video jobs fail immediately with a clear message instead of failing mid-run on a model that is no longer available.
## Chat math, billing accuracy, files, and privacy
### New features
* **Math and LaTeX render in assistant replies.** Formulas and equations in assistant messages display as formatted math instead of raw markup, so technical and scientific answers are easier to read.
### Improvements
* **Chat usage reflects knowledge base, memories, and connectors.** Credits charged per message now include context from your agent knowledge base, saved memories, and enabled connectors, so usage history matches what the model actually processes.
### Fixes
* **Downloads work for files with special characters in the name.** Files whose names include parentheses, spaces, or other special characters download and preview correctly from Knowledge Base, Spaces, and chat instead of failing with an invalid link error.
* **Chat sidebar respects workspace privacy by default.** You only see other teammates' conversations in the sidebar when your workspace explicitly enables that visibility, preventing accidental exposure of private chats.
## Chat, Cowork, billing, connectors, and generator previews
### Fixes
* **PIX payments activate your subscription again.** After you pay for a plan through Pagar.me (including PIX), your access is granted as soon as the payment confirms, even if you leave the checkout page to complete payment in your banking app.
* **Edited messages keep their original context.** When you edit a message you already sent, the regenerated answer reuses the original attachments, memory collections, and connectors instead of silently switching to whatever is in the compose bar now.
* **Yearly plan upgrades keep your subscription active.** Upgrading from a non-Pagar.me plan onto a Pagar.me-integrated annual plan no longer triggers stray billing that can cancel your access weeks later.
* **Cowork uses the correct local date and time.** Digital employee runs now include a precise timestamp in their run state, so scheduled digests and calendar-connected automations target the right day in your configured timezone.
* **LinkedIn connector calls work with empty parameters.** Scheduled automations that query LinkedIn no longer fail when a tool needs an empty argument object, so connector actions complete instead of stopping the entire run.
* **Chat no longer crashes on send.** Messages that previously failed when the chat thread ID was missing now send correctly, and unexpected server errors no longer expose raw technical details.
* **Generator previews reflect your options.** Changing duration, resolution, image size, or quality in image and video generators updates the credit estimate before you run, so the preview matches what you will be charged.
## Chat reliability, generators, memory, and file previews
### Fixes
* **Reference-image video generation works again.** Video Generator now sends optional attachment fields correctly, so generations that rely on a reference image proceed instead of failing on a corrupted upload value.
* **Chat image tools follow your prompt more reliably.** Image creation in chat uses clearer defaults and confirmation when composing from multiple image tools, reducing unrelated or random outputs.
* **Clear feedback when memory edits hit your credit cap.** If your monthly credit limit blocks a memory update, you see an inline explanation instead of the edit failing silently.
* **PDF previews stay stable.** Opening a PDF in Spaces or chat no longer reloads endlessly in the background or drives your browser tab to freeze.
* **Anthropic chats finish when the answer is done.** Replies on Anthropic models stop streaming right after the last token instead of leaving a spinner running for minutes after the response is complete.
* **Help bubble no longer blocks send.** The in-app support messenger stays above the prompt area without covering the send button in chat and Cowork.
* **Downloads work for agent-created files in chat.** Files your agent generates with durable references open and download correctly from the chat file viewer.
## Connector limits, Microsoft integrations, and chat file reliability
### New features
* **Configurable connector limits per workspace.** Workspace admins can set how many connector toolkits stay active in a single chat, within platform guardrails, so large integration setups stay manageable without overloading the agent.
### Fixes
* **Microsoft connectors work again.** Outlook, SharePoint, and Microsoft Graph connections authorize and run reliably after fixes to how connector identities are resolved.
* **Cowork stops looping on connector reconnect.** Agents using multi-part integration names no longer get stuck in an endless reconnect cycle when a toolkit is temporarily unavailable.
* **Generated files keep working across chat turns.** Files your agent creates in a conversation keep a durable identity, so follow-up tool calls and later turns can reference them correctly instead of losing track.
## Cowork workspace, code execution, Chat images, AI Studio, embedded agents, and generators
### Fixes
* **Cowork workspace switching works again.** Switching workspaces from inside Cowork no longer freezes the page or leaves the switcher stuck on a spinner — you land back on Cowork in the destination workspace.
* **Code runs no longer halt the whole conversation.** Research and analysis tasks that use code execution keep going when output contains ordinary data that was previously misread as a failure, so your agent can continue using tools instead of stopping the entire round.
* **No duplicate charges on subscription renewal.** Annual plans that renew automatically are protected so the same billing period cannot be charged twice on renewal day.
* **Embedded agents no longer show a false credit paywall.** Visitors on a public embed link can use the agent when the workspace has credits instead of seeing a misleading no-credits message before any request is sent.
* **Knowledge Base training completes in AI Studio.** Training files in an agent knowledge base no longer get stuck on Training — the studio polls progress and updates status so you can add, remove, or run the agent again.
* **Failed tool runs show the right status after reload.** When a tool attempt fails, reloading the chat no longer leaves a frozen preparing-tool chip — the conversation reflects the failed state correctly.
* **Arrow symbols render correctly in chat.** Directional arrows in model responses display as proper symbols instead of unreadable formula text.
* **Long prompts scroll in Image and Video Generator.** The prompt field grows to a comfortable height and then scrolls, so you can read, edit, and select all of your text without losing the Generate button off-screen.
* **Chat recognizes images on the first turn.** Uploaded images are sent to vision models correctly instead of being misrouted through text search, so the model can describe and reason about your pictures right away.
## Custom MCP OAuth, Cowork, chat reliability, and workspace access
### New features
* **Connect OAuth-based Custom MCP servers.** Workspace admins can authorize hosted MCP integrations that require a browser login flow, so services like Attio work without static API keys.
* **Connection to custom OAuth-based MCP servers.** Workspace admins can authorize hosted MCP integrations that require a browser login flow, so services like Attio work without static API keys.
### Improvements
* **Clearer tool call status in chat.** Failed tool runs now show a neutral gray "attempted" label instead of a red error chip, so connector retries feel less alarming during everyday agent work.
### Fixes
* **Cowork control center loads again.** The digital employee monitor and related Cowork panels load without the "Some layers failed to load" error.
* **Cowork canvas keeps children with moved parents.** When you drag an agent to set a parent, unpinned child agents stay near the parent instead of snapping to a distant default slot.
* **Chat opens without freezing.** Conversations load reliably again when model info tooltips initialize, including agents that run in the background.
* **File attach errors explain what went wrong.** Upload failures in chat now show the real backend message instead of a generic error toast.
* **File downloads work across environments.** Downloading files from Spaces and chat no longer fails with an invalid signature error on certain workspaces.
* **Embedded agent file links open correctly.** Visitors on a customer's embedded agent can click generated file links and open downloads in a new tab.
* **Team management visible on Members page.** Workspace admins who can manage teams now see team settings when a member has no team assigned.
## Help & Support and in-app bug reporting
### Fixes
* **Help & Support opens correctly again.** Opening Help & Support or reporting an issue from the dashboard now loads the support messenger instead of showing a blank panel.
## Workspace invites, Cowork, connectors, and chat reliability
### New features
* **Assign a team when inviting members.** Workspace admins can pick a team for email invites and secret invite links so new members land in the right group without extra setup after they join.
### Improvements
* **Smoother Cowork work instructions pasting.** Pasting instructions over the character limit keeps your text in the editor with a clear counter and save guidance instead of silently discarding what you pasted.
* **Account menu email shows as plain text again.** Your signed-in email in the account menu displays as a label instead of a clickable link.
### Fixes
* **Chat keeps running when history data is malformed.** Conversations with broken indexed history or missing attachments no longer show a generic provider error and block the thread.
* **Editing a sent message works again.** Send, Cancel, and the restart warning on message edits apply your change instead of failing silently.
* **Live HTML preview returns for generated sites.** When chat creates an HTML site, you see the visual preview again without opening files manually.
* **Fewer false temporary provider errors in chat.** Transient tool-loop failures retry once before showing an error, with clearer messages when they persist.
* **Attio connector works in Auto mode.** Using Attio with Auto models no longer fails with a generic provider error after the tool limit kicks in.
* **Outlook connector reads your messages reliably.** Agents using Outlook no longer get stuck in a catalog check loop that reports a temporary access issue.
* **Public embed agents can use knowledge-base files.** Visitors on a public agent link can access files linked to that agent knowledge base.
* **Cowork input cards stay dismissed.** Dismissing or answering a digital employee input request no longer lets the card reappear and fail on a second click.
* **Custom CRON schedules show the right cadence.** Interval-plus-weekday schedules like every 30 minutes on weekdays display correctly instead of once per day.
* **Voice calls respect your credit cap.** Digital employee voice calls block before connecting when your workspace monthly credit limit is reached, with a clear explanation.
* **Connector batches count toward your subtasks limit.** Multi-action connector runs consume one subtask per nested action, and the limit alert clears when you switch chats.
* **Browser extension setup lists your workspaces.** Signing into the Tess browser extension seeds your workspace so the picker is populated and mismatch errors are clearer.
* **Invite mismatch page shows your real email.** When an invite was sent to a different address, the signed-in email decodes correctly as plain text instead of a broken placeholder.
## Agent Mode integrations, Skills settings, and chat reliability
### New features
* **Import skills from a ZIP file.** You can add custom skills to your workspace by uploading a packaged ZIP from Personal Settings, with a dedicated modal and drag-and-drop flow.
* **Custom MCP servers work in Agent Mode.** Workspace-configured custom MCP integrations now load in Agent Mode, and tool chips show a clear server and action name instead of an internal label.
* **Choose which connected apps Agent Mode can use.** When enabled for your workspace, you can pick which connected apps an Agent Mode session may access instead of exposing every app you have ever linked.
### Improvements
* **More accessible Skills settings.** Skill cards now include screen-reader labels on toggles and menus, clearer empty states when search finds nothing, and smoother skeleton loading while the grid loads.
### Fixes
* **Reasoning model stays selected after your first message.** Picking a reasoning effort level before you send no longer resets the in-chat model chip to Auto.
* **Knowledge-base uploads finish training.** Files added to an agent knowledge base no longer get stuck in an endless loading state or block you from adding the next file.
* **Bulk file downloads no longer sign you out.** Downloading all generated chat files handles an expired session gracefully instead of logging you out of the platform.
* **Agent steps no longer show false failure notices.** Step-failure alerts appear only when a real step error occurred, so successful runs are not marked as failed.
* **Follow-up messages keep context after a cut-off reply.** In economy mode, continuing a conversation after a truncated answer keeps the original request in context.
* **Clear guidance when tool calls fail repeatedly.** If tools keep failing in the same turn, you now get an explanation and a chance to confirm before the agent tries again.
* **Chat no longer blocks on empty input retries.** Retrying or sending a message with an empty input field no longer shows a blocking error toast.
## Chat history limits and subscription credit refills
### Improvements
* **Conversation history fallback now respects your token budget.** If the history indexer cannot summarize older messages, Tess trims what gets sent to the model to match your mode limits and shows a brief "Summarizing conversation history" status so you know the chat is using a fallback path.
### Fixes
* **Monthly credit refills on subscription renewals.** Fixed a regression where some plan renewals did not apply your monthly credit top-up after billing.
## Chat, Cowork, connectors, and file handling
### Improvements
* **Model detail tooltips open after a short pause.** Hovering through the model list no longer triggers accidental pop-ups; panels open only after you pause on an option for half a second.
* **Clearer message when a model times out.** When a model fails to respond in time, you see plain guidance to try another model and send again instead of a technical error.
* **Browser extension handles large pages.** Heavy web pages are saved to your workspace so agents can work with the full content instead of truncated snippets.
* **Cowork warns when connectors need reconnect.** Mesh nodes and the agent drawer show when a connector lost authentication, with a direct path to reconnect before more runs fail.
* **Usage export reflects Cowork activity.** CSV exports now label Cowork-backed runs with the Digital Employee name so usage reports match what you see in the product.
### Fixes
* **Chat stays responsive through reconnects and tool runs.** Reconnecting no longer leaves the composer out of sync, and tool chips appear as the response finishes instead of only after a refresh.
* **Dense PDFs and large text files ingest reliably.** Knowledge-base PDFs with dense pages and large TXT attachments now process successfully instead of failing silently or showing a generic error.
* **Connector setup respects your team policies and app type.** Allowed connectors no longer get blocked by internal integration checks, and OAuth setup shows the right app-specific guidance instead of generic copy.
* **Spaces filters show the human owner you selected.** Filtering by user now highlights the person you picked as the primary owner while keeping the creating Autopilot as secondary context.
* **Cowork runs stay mapped and readable.** Orphan runs bind to the correct execution, live tables no longer collect protocol residue as data rows, and you see when an agent is waiting for your answer with an honest schedule label.
* **Active subscriptions keep platform access.** Paying users are no longer locked out when billing-period data is still syncing.
* **Earlier API keys visible in settings again.** API keys created before a recent platform update appear in your settings again for review and revocation.
## Chat reliability and subtasks limits
### Improvements
* **Max Subtasks limit you set is what chat enforces.** Your Max Subtasks per Prompt preference now matches runtime behavior in chat. When the limit is reached, you see a clear alert with Continue and Adjust Limit, and Continue sends a follow-up so the agent can resume instead of leaving you stuck.
### Fixes
* **Chat history opens after interrupted tool runs.** Viewing past conversations no longer crashes when a tool call was interrupted before it finished, including shared audit views of other members' chats.
## Credit caps, chat completion, and memory privacy
### Fixes
* **Accurate monthly credit cap totals.** Per-member monthly credit caps now show consumption that matches the usage report export, including tool, file, and knowledge-base charges attributed to the right team member.
* **Complete answers when responses hit length limits.** Chat agents that reach the model output limit now automatically continue generating instead of leaving you with a mid-sentence partial answer.
* **Safer memory retrieval in chat.** Memory search now only pulls from memories you own, so unrelated memories cannot appear in your conversations.
## Chat polish, connectors, Agent Studio, and API reliability
### Improvements
* **Richer assistant message formatting.** Answers in the main chat now render headings, lists, tables, and code blocks with cleaner typography, better spacing, and a copy button on code snippets.
* **Lighter chat startup.** Opening chat loads fewer duplicate scripts, so the page boots faster without changing how credit warnings or session behavior work.
* **Extended grace period for API workspace identification.** Integrations that have not yet added the required workspace header to API calls continue to work through August 2026, giving you more time to update without unexpected request failures.
### Fixes
* **Gemini 2.5 Pro error recovery.** Recoverable connection or provider issues no longer surface as a blocking technical error or leave the send button stuck when using Gemini 2.5 Pro in chat.
* **Agent visibility indicator.** The checkmark in the agent visibility dropdown now matches the option you selected instead of highlighting the wrong sharing level.
* **Accurate execution status during long connector runs.** Agent runs that are still processing connector actions are no longer marked as failed in usage history while work is still in progress.
* **Generated file preview on existing chats.** Clicking a generated-file chip in a message opens the preview modal when you open an existing conversation from the sidebar, a link, or a refresh.
* **Gmail connector tool availability.** Agents using Gmail connectors can reach draft and send actions again when outdated tool names were blocking execution.
* **Agent Studio knowledge base file limits.** The upload area now shows the real capacity, warns when you reach the limit, and lets you choose which files to keep when a batch exceeds it.
* **Connector resilience after repeated tool errors.** Repeated format errors on one connector action no longer disable the entire integration for the rest of the run.
* **Site publishing from agents.** Publishing a site from agent chat works again without authentication errors blocking registration.
## Chat reliability, connectors, cowork, and faster page loads
### Improvements
* **Faster initial page load.** The app now loads chat tool panels only when you need them, so every authenticated screen starts quicker without changing how tools behave in chat.
### Fixes
* **Clean chat message copy.** Copying a chat answer now pastes with proper formatting and no dark background or raw markdown symbols when you paste into email, documents, or other apps.
* **Reliable daily credit refills.** Daily credits now refill according to your subscription owner's time zone, so you receive your allowance on the expected day.
* **Reliable Gmail bulk sending.** Bulk email sends through the Gmail connector now report accurate per-message results even when responses are truncated.
* **Gmail attachments in chat.** Agents can send emails with workspace file attachments through Gmail without misleading authorization errors.
* **Cowork work instructions and status.** Magic Prompt no longer silently truncates work instructions at the character limit, and employee status in the cowork mesh updates correctly when you hover over agents.
* **Cowork connector reconnection.** Digital employees stop prompting you to reconnect integrations that are already connected, ending infinite reconnection loops in cowork chat.
* **Workspace invite access.** Invited users who log in through an invite link now land in the correct workspace with clearer session choice messaging.
* **Audio generation in Portuguese.** The Audio Generator completes voice-over generation for Brazilian Portuguese voices instead of stalling after you submit your script.
* **Skills settings layout.** Long skill names no longer block toggles for other skills in your personal settings grid.
* **Pipedrive connector setup.** You can connect Pipedrive to your workspace again when API key authentication was failing during credential validation.
* **Computer image preview.** Images generated by the agent in chat display inline in the Computer panel instead of showing an unavailable preview.
* **Preventive media credit caps.** When monthly credit caps are enabled for workspace members, image, video, and voice generations are blocked before they start if the estimated cost would exceed the member's remaining allowance.
## Chat reliability, tool governance, and generator uploads
### New features
* **Large chat pastes become attachments.** When you paste a long block of text into the chat composer, it automatically becomes a file attachment instead of flooding the input or hitting character limits. With Smart Search enabled, very large pasted files are indexed so the assistant can retrieve relevant sections instead of loading the entire document every turn.
* **Agent tool group governance.** Workspace admins can restrict which chat tool groups—such as web search, image generation, and integrations—each team or member may use, matching the existing models and connectors governance controls.
* **Browser extension for local automation.** Connect a Chrome extension to run browser tasks on your own machine during chat, with layered access controls for teams that enable this capability.
### Improvements
* **Clear recovery when providers stall.** If an AI provider accepts a connection but stops sending tokens, chat now times out after 90 seconds with a dedicated message and quick actions to switch models or retry, instead of hanging silently for long stretches.
### Fixes
* **Video and image generators with uploaded references.** Playground agents that use reference uploads—such as video upscaling—now send direct file links to external providers instead of internal redirects that caused generation to fail.
* **Tool chips and thinking panel in chat.** Connector results no longer leak raw JSON into the Thinking panel during streaming, tool chips stay in the right place after refresh, and the chat header shows Thinking and Responding while the assistant is still writing.
* **Image analysis for mislabeled files.** Chat vision analysis now detects the real image format from file bytes instead of trusting the stored file type, preventing provider errors when a file extension does not match its contents.
* **Workspace files modal during refreshes.** Selecting files in the workspace files modal no longer closes the panel when the file list refreshes in the background after an agent response.
* **Governance access to private workspace files.** Workspace managers with document-read governance permission can open colleagues' private files through document references, consistent with access rules already applied to chat execution results.
* **Tool restrictions across all categories.** When admins limit which tool groups a member can use, those restrictions now apply consistently across every category in the chat tool picker instead of mixing fresh and cached results.
## MCP server and API integrations
### Improvements
* **Cleaner MCP tool catalog.** The hosted MCP server now lists only documented public API tools, so you no longer see internal or non-working endpoints when connecting agents through MCP.
## Workspace governance, COWORK chart, and digital employee attachments
### New features
* **Role-based delete controls.** Workspace admins can grant or revoke, per role, who may permanently delete chats and files, agents and automations, or memories — delete buttons hide when permission is missing, and the API blocks unauthorized attempts.
### Fixes
* **Full-org COWORK chart loads reliably.** Switching Mission Control to the whole-organization view no longer hangs on loading layers or fails on large teams; failed loads now show a clear error instead of spinning forever.
* **Attached files used in omnibar tasks.** Digital employees now use attached documents even when your instruction is broad (for example, summarize this), reading from the start of each file instead of behaving as if nothing was attached.
## Connectors, workspace files, chat reliability, and voice billing
### New features
* **Full connector results saved for agent analysis.** When a connected app returns a very large dataset, Tess saves the complete response to your conversation workspace so agents in Agent Mode can analyze the full payload with code instead of working with a truncated excerpt.
### Improvements
* **Faster Connectors modal in chat.** Opening and searching the Connectors catalog loads more quickly, the list stays visible while you type, and revisiting the modal in the same session shows your last results instantly.
* **Clear block when credits run out.** If your workspace has no credits left, you cannot start a new voice call and see a clear message explaining why.
* **Voice usage in your usage report.** Completed voice calls appear in the workspace usage report alongside other credit-consuming activity.
### Fixes
* **Knowledge base uploads from chat work again.** Adding a chat attachment to your knowledge base completes successfully instead of failing before the upload starts.
* **Set as home agent in Agent Studio works again.** Defining an agent as your workspace home agent from the studio actions menu now completes the action instead of failing silently.
* **Agent-generated documents preview correctly.** Documents created by agents such as spreadsheets, PDFs, and presentations now open with the correct format instead of downloading as generic binary files.
* **Agent-created files appear in chat reliably.** Files your agent produces during a turn now show up as downloadable cards in the conversation even when intermediate tool steps mix success and failure.
* **Chat recovers after agent workspace images.** Conversations no longer fail on every reply after an image from agent tools enters the thread—follow-up messages send normally again.
* **Voice calls now consume workspace credits.** Digital employee voice calls deduct credits from your workspace based on actual token usage, so usage aligns with the configured voice pricing.
* **Each voice call is billed only once.** Ending the same call twice no longer risks a duplicate charge.
* **Agent runs and image generation finish promptly.** API executions that wait for completion and image generation confirm screens now return as soon as the work finishes instead of hanging for several minutes.
## Agent Mode, chat reliability, reasoning display, and performance
### Improvements
* **Clearer Agent Mode credit requirements.** When your workspace balance or personal monthly cap is too low for Agent Mode, chat explains why you cannot switch modes and what you can do next instead of showing a generic error.
* **Polished reasoning trail in chat.** When a reasoning-capable model answers, you see a smooth "Thinking…" pulse with a live reasoning trail that collapses into "Thought for Xs" once reasoning ends—the same design after a page reload.
* **Faster files panel in chat.** Opening the files and knowledge base panel loads your workspace files much more quickly, especially in large workspaces.
* **Faster chat history loading.** Agent conversation lists load promptly instead of hanging on workspaces with many embedded chats.
### Fixes
* **Embedded chat history for your workspace.** Workspace members can find and open embedded anonymous visitor chats in usage history and governance views, with links that open under the correct workspace.
* **Removing chat attachments works again.** Detaching a file from the compose box deletes it on the server as expected instead of only hiding the thumbnail.
* **Chat history opens reliably on first click.** Switching conversations from the sidebar or search results no longer fails silently right after the page loads.
* **Shareable chat clones work again.** Cloning a conversation from a link completes successfully instead of stopping with an error.
* **No empty bubble while the model thinks.** The agent name and answer bubble appear only when visible answer text starts streaming—you no longer stare at an empty named bubble during reasoning.
## Chat streaming, usage history, checkout, and agent embedding
### Improvements
* **Smoother chat streaming.** Responses arrive in the right order, tool markers land in sensible places, and long conversations keep rendering smoothly without freezing mid-generation.
* **Richer usage history filters.** You can filter usage by connector calls, tool runs, file uploads, transcription, knowledge-base indexing, background processing, and more when reviewing workspace consumption.
* **Connectors in API agent runs.** Agents triggered through the API or hosted MCP server now activate configured workspace connectors the same way they do in chat.
### Fixes
* **Usage history matches deducted credits.** Background charges such as auto-route, search planning, and memory jobs now appear on the correct execution rows, so reported usage aligns with credits actually consumed.
* **Reliable checkout activation.** Completing a paid plan checkout consistently delivers your subscription and credits instead of failing silently after payment.
* **Clearer agent embed setup.** The embedding configuration modal shows a readable title, copy buttons guide you to enable public access first, and anonymous embed visitors no longer see irrelevant credit warnings.
## Chat streaming, usage history, checkout, and agent embedding
### Improvements
* **Smoother chat streaming.** Responses arrive in the right order, tool markers land in sensible places, and long conversations keep rendering smoothly without freezing mid-generation.
* **Richer usage history filters.** You can filter usage by connector calls, tool runs, file uploads, transcription, knowledge-base indexing, background processing, and more when reviewing workspace consumption.
* **Connectors in API agent runs.** Agents triggered through the API or hosted MCP server now activate configured workspace connectors the same way they do in chat.
### Fixes
* **Usage history matches deducted credits.** Background charges such as auto-route, search planning, and memory jobs now appear on the correct execution rows, so reported usage aligns with credits actually consumed.
* **Reliable checkout activation.** Completing a paid plan checkout consistently delivers your subscription and credits instead of failing silently after payment.
* **Clearer agent embed setup.** The embedding configuration modal shows a readable title, copy buttons guide you to enable public access first, and anonymous embed visitors no longer see irrelevant credit warnings.
## Usage history, agent governance, and connector reliability
### New features
* **Unlisted agent governance for managers.** Workspace managers with the right permissions can list, edit, and publish colleagues' unlisted agents in Agent Studio while creators keep full control of their own agents.
### Improvements
* **Richer workspace usage API responses.** Token counts, model names, and execution mode (agent or chat) are now included in each item returned by the workspace usage API, so admins and integratioworkspace usage API responses. Token counts, model names, and execution mode (agent or chat) are now included in each item returned by the workspace usage API, so admins and integrations can distinguish agent runs from chat and investigate billing more accurately.
* **Clearer anonymous visitors in usage history.** Embedded chat visitors display as anonymous users in usage reports and exports instead of confusing placeholder email addresses.
* **Clearer referral messaging.** The referral button now invites you to recommend Tess to a friend, with updated reward copy in all supported languages.
### Fixes
* **Monday.com connector setup.** Step-by-step guidance appears when your workspace is missing prerequisites, with clearer recovery when authorization is interrupted.
* **Model info See More link.** The See More link in model tooltips only appears when it points to useful documentation, not icon or image URLs.
* **Agent form and AI generator pages.** Fixed an error that blocked opening agent create and edit forms and some AI generator pages.
## Billing governance, downloads, chat stability, and agent publishing
### Improvements
* **Scheduled agents pause on cancellation.** When a workspace owner's subscription is cancelled, scheduled agents in that workspace are automatically paused so they do not keep running and consuming credits.
### Fixes
* **Chat after image attachments.** Fixed a recurring provider error in conversations that included certain image attachments, so follow-up messages send reliably again.
* **Skill and file downloads.** Restored working download links for skills, workspace files, and files attached in chat.
* **Site publishing from agents.** You can publish sites from agent chat again without configuration errors blocking the action.
* **Prepaid credit purchases.** Fixed a failure that could occur when updating prepaid credits after a subscription payment.
## AI Studio, digital employees, usage history, and chat reliability
### New features
* **Talent Pool digital employees.** Browse pre-built digital employees with app connections already configured, so you can deploy useful agents faster without wiring integrations from scratch.
* **Updated image and video models in AI Studio.** Generator models in AI Studio now stay in sync with the latest available options, keeping creative workflows current.
* **Agent Studio access for lite users via Team Board.** Lite plan users can now open Agent Studio when entering through Team Board, expanding self-serve agent discovery without a full upgrade.
* **Richer usage history for large workspaces.** Usage history loads more reliably at scale and supports dynamic filters by execution type, making audit and cost review easier for admins.
### Improvements
* **Clearer chat attachments in messages.** Attached files now always render in the user message area, so shared context stays visible throughout the conversation.
### Fixes
* **Image upscale stability.** Fixed a crash when using 2x upscale in the image generator.
* **Phantom tool calls with auto tools off.** Resolved cases where tool actions appeared even when automatic tool selection was disabled.
* **Playground gallery after generation.** The gallery view now returns correctly once an image or video generation completes.
* **Duplicate workspace owners.** Prevented edge cases that could assign more than one owner during workspace setup.
* **Connector tools with empty settings.** Connectors with blank configuration schemas now load correctly in chat instead of failing silently.
## Memory import and chat stream reliability
### New features
* **Memory import from other AI tools.** Import memories from other AI providers during onboarding or from preferences, with progress tracking and a follow-up in chat.
### Fixes
* **Chat stream resumption.** Improved reliability when resuming a chat stream after missing elements in the conversation view.
## Chat thinking state, attachments, and UI polish
### New features
* **Paste long text as attachment.** The composer turns large pasted text into a clean attachment instead of flooding the input box.
### Improvements
* **Chat thinking state and agent reveal.** While you wait for a reply, you see the Tess logo with rotating status messages and a smooth transition to the agent identity when streaming starts.
* **Onboarding invite share on dark theme.** Invite share dropdown is readable on dark UI.
* **Support reply indicator.** A Gleap bubble appears when support replies are unread.
### Fixes
* **Role dropdown stays open while scrolling.** Role menu no longer closes on internal scroll.
* **Navbar layout routing.** Correct routing for legacy and v2 navbar layouts.
* **Subscription shortcut permissions.** Settings hide the subscription shortcut without billing write permission.
## Workspace roles, chat files, SSO, and connectors
### New features
* **Custom workspace roles.** Workspace owners can create roles from templates, with permissions that respect your plan and stay consistent when the feature catalog changes.
* **Knowledge Base in the files modal.** Knowledge Base files and links now live alongside chat files in one unified modal.
### Fixes
* **Enterprise SSO login.** Fixed failures that blocked SSO login completion for some enterprise tenants.
* **Connector reconnect in chat.** When a connector session expires, the chat shows a reconnect chip instead of failing silently.
* **SemRush connector errors.** Connection errors from the provider are surfaced clearly when linking SemRush.
## Background LLM, uploads, and file downloads
### Improvements
* **Background LLM fallback.** Background LLM work can fall back across services when the primary path fails.
### Fixes
* **Clear errors for bad audio uploads.** Invalid transcription uploads return structured errors instead of opaque failures.
* **Downloads for agent-generated Office files.** PPTX, DOC, and XLS produced by agents download correctly from chat.
* **Legacy Space file downloads.** Legacy knowledge-base files in Spaces expose a working download URL.
* **Memory Collections identifier validation.** Invalid collection IDs should fail gracefully instead of a generic server error—confirm customer-facing API impact.
## Chat reliability and connector tools
### Fixes
* **First-message chat step errors.** The first message in a chat no longer fails with a broken step error.
* **Connector tools in Digital Employee editor.** Integration and connector tools load fully in the digital employee editor and voice discovery.
## Chat attachments and wallet clarity
### Improvements
* **Compact markdown images in chat.** Images in assistant markdown render as small link chips so long threads stay readable.
### Fixes
* **Magic Prompt and Background LLM reliability.** Magic Prompt no longer fails with server errors, and model customization works in background LLM runs.
* **Wallet state for uncapped members.** Members without a personal usage cap no longer see stale open-usage wallet state.
* **Smarter chat file context.** The latest edited file and current-turn smart-search attachments are passed to the model so answers match what you attached.
* **Agent version baseline for legacy agents.** Backfill adds a v1 baseline for agents missing version history—confirm whether workspace-visible behavior changes.
* **Chat credit calculation guard.** Guards credit calculation when chat context is incomplete—confirm user-visible billing impact.
## Usage history, agent governance, and connector reliability
### New features
* **Unlisted agent governance for managers.** Workspace managers with the right permissions can list, edit, and publish colleagues' unlisted agents in Agent Studio while creators keep full control of their own agents.
### Improvements
* **Richer usage history details.** Token counts, model names, and execution mode now appear in workspace usage history so admins can distinguish agent runs from chat and investigate billing more accurately.
* **Clearer anonymous visitors in usage history.** Embedded chat visitors display as anonymous users in usage reports and exports instead of confusing placeholder email addresses.
* **Clearer referral messaging.** The referral button now invites you to recommend Tess to a friend, with updated reward copy in all supported languages.
### Fixes
* **Monday.com connector setup.** Step-by-step guidance appears when your workspace is missing prerequisites, with clearer recovery when authorization is interrupted.
* **Model info See More link.** The See More link in model tooltips only appears when it points to useful documentation, not icon or image URLs.
* **Agent form and AI generator pages.** Fixed an error that blocked opening agent create and edit forms and some AI generator pages.
## Billing governance, downloads, chat stability, and agent publishing
### Improvements
* **Scheduled agents pause on cancellation.** When a workspace owner's subscription is cancelled, scheduled agents in that workspace are automatically paused so they do not keep running and consuming credits.
### Fixes
* **Chat after image attachments.** Fixed a recurring provider error in conversations that included certain image attachments, so follow-up messages send reliably again.
* **Skill and file downloads.** Restored working download links for skills, workspace files, and files attached in chat.
* **Site publishing from agents.** You can publish sites from agent chat again without configuration errors blocking the action.
* **Prepaid credit purchases.** Fixed a failure that could occur when updating prepaid credits after a subscription payment.
## AI Studio, digital employees, usage history, and chat reliability
### New features
* **Talent Pool digital employees.** Browse pre-built digital employees with app connections already configured, so you can deploy useful agents faster without wiring integrations from scratch.
* **Updated image and video models in AI Studio.** Generator models in AI Studio now stay in sync with the latest available options, keeping creative workflows current.
* **Agent Studio access for lite users via Team Board.** Lite plan users can now open Agent Studio when entering through Team Board, expanding self-serve agent discovery without a full upgrade.
* **Richer usage history for large workspaces.** Usage history loads more reliably at scale and supports dynamic filters by execution type, making audit and cost review easier for admins.
### Improvements
* **Clearer chat attachments in messages.** Attached files now always render in the user message area, so shared context stays visible throughout the conversation.
### Fixes
* **Image upscale stability.** Fixed a crash when using 2x upscale in the image generator.
* **Phantom tool calls with auto tools off.** Resolved cases where tool actions appeared even when automatic tool selection was disabled.
* **Playground gallery after generation.** The gallery view now returns correctly once an image or video generation completes.
* **Duplicate workspace owners.** Prevented edge cases that could assign more than one owner during workspace setup.
* **Connector tools with empty settings.** Connectors with blank configuration schemas now load correctly in chat instead of failing silently.
## Memory import and chat stream reliability
### New features
* **Memory import from other AI tools.** Import memories from other AI providers during onboarding or from preferences, with progress tracking and a follow-up in chat.
### Fixes
* **Chat stream resumption.** Improved reliability when resuming a chat stream after missing elements in the conversation view.
## Chat thinking state, attachments, and UI polish
### New features
* **Paste long text as attachment.** The composer turns large pasted text into a clean attachment instead of flooding the input box.
### Improvements
* **Chat thinking state and agent reveal.** While you wait for a reply, you see the Tess logo with rotating status messages and a smooth transition to the agent identity when streaming starts.
* **Onboarding invite share on dark theme.** Invite share dropdown is readable on dark UI.
* **Support reply indicator.** A Gleap bubble appears when support replies are unread.
### Fixes
* **Role dropdown stays open while scrolling.** Role menu no longer closes on internal scroll.
* **Navbar layout routing.** Correct routing for legacy and v2 navbar layouts.
* **Subscription shortcut permissions.** Settings hide the subscription shortcut without billing write permission.
## Workspace roles, chat files, SSO, and connectors
### New features
* **Custom workspace roles.** Workspace owners can create roles from templates, with permissions that respect your plan and stay consistent when the feature catalog changes.
* **Knowledge Base in the files modal.** Knowledge Base files and links now live alongside chat files in one unified modal.
### Fixes
* **Enterprise SSO login.** Fixed failures that blocked SSO login completion for some enterprise tenants.
* **Connector reconnect in chat.** When a connector session expires, the chat shows a reconnect chip instead of failing silently.
* **SemRush connector errors.** Connection errors from the provider are surfaced clearly when linking SemRush.
## Background LLM, uploads, and file downloads
### Improvements
* **Background LLM fallback.** Background LLM work can fall back across services when the primary path fails.
### Fixes
* **Clear errors for bad audio uploads.** Invalid transcription uploads return structured errors instead of opaque failures.
* **Downloads for agent-generated Office files.** PPTX, DOC, and XLS produced by agents download correctly from chat.
* **Legacy Space file downloads.** Legacy knowledge-base files in Spaces expose a working download URL.
* **Memory Collections identifier validation.** Invalid collection IDs should fail gracefully instead of a generic server error—confirm customer-facing API impact.
## Chat reliability and connector tools
### Fixes
* **First-message chat step errors.** The first message in a chat no longer fails with a broken step error.
* **Connector tools in Digital Employee editor.** Integration and connector tools load fully in the digital employee editor and voice discovery.
## Chat attachments and wallet clarity
### Improvements
* **Compact markdown images in chat.** Images in assistant markdown render as small link chips so long threads stay readable.
### Fixes
* **Magic Prompt and Background LLM reliability.** Magic Prompt no longer fails with server errors, and model customization works in background LLM runs.
* **Wallet state for uncapped members.** Members without a personal usage cap no longer see stale open-usage wallet state.
* **Smarter chat file context.** The latest edited file and current-turn smart-search attachments are passed to the model so answers match what you attached.
* **Agent version baseline for legacy agents.** Backfill adds a v1 baseline for agents missing version history—confirm whether workspace-visible behavior changes.
* **Chat credit calculation guard.** Guards credit calculation when chat context is incomplete—confirm user-visible billing impact.
## Chat file references and image reliability
### Fixes
* **Image chip in agent mode.** Fixed cases where an image attachment chip disappeared after being selected.
* **Inline document and image links.** Document and image references in chat messages resolve and display correctly, including in agent mode.
* **Image compare mode.** Restored compare mode for image inputs that use durable file references.
* **Model selector search highlight.** Fixed misaligned row highlight when filtering models in the grouped chat selector.
* **File details without storage URL.** Opening file details no longer crashes when optional storage URLs are missing.
## Autopilot approvals and connector actions
### New features
* **Batch decision queue.** When an autopilot run needs your approval on connector actions, review them in a card deck—approve, edit, reject, or skip each item, then submit the whole batch at once.
### Improvements
* **Clearer autopilot work modes.** Work modes are labeled Autonomous and Supervised, with Supervised as the default. You can also choose a manual-only schedule that runs only when you trigger it.
* **Ghost plan timeline.** Pending approval steps appear on an interactive timeline so you can see where each decision sits in the run.
### Fixes
* **LinkedIn publishing detection.** Safer detection when an autopilot action targets LinkedIn publishing.
* **User input in run results.** Answered user-input requests now show every field in the run output, not just the first one.
## Advances in documents, chat, and stability
### New features
* **Smart document linking.** You can now connect and organize documents in a more integrated way, making it easier to continue and retrieve information.
* **Content recovery commands.** New commands allow you to restore or adjust content automatically, improving information management.
### Improvements
* **More consistent display of actions in chat.** Adjustments to how interactions and tools are presented, making usage clearer and more predictable.
* **Content listing performance.** Optimizations that make navigating and loading lists faster.
### Fixes
* **Server error in specific chats.** Fixed an issue that prevented usage in some cases, ensuring greater stability during conversations.
## Onboarding fixes and improvements in model selection
### Improvements
* **Enhanced model selection (conditional access).** A new way to choose models with reasoning level options, allowing greater control over response behavior.
### Fixes
* **Onboarding flow.** Fixed an issue that allowed redoing onboarding and generating duplicate agents.
## Improvements in credits, chat, and stability
### New features
* **Enhancements in on-screen element detection.** Improvements in how content is dynamically loaded and displayed, providing smoother navigation.
### Improvements
* **More reliable credit top-ups.** Adjustments to the payment system to ensure credits are added correctly.
* **Clearer messages and feedback on login.** Better communication when redirecting users during account access.
* **Interface stability and consistency.** General improvements that make the experience more predictable and free of visual inconsistencies.
### Fixes
* **Sending messages in agents.** Fixed an issue that prevented sending after filling required fields.
* **Magic Prompt restored.** Functionality is now working correctly again in chat and in the image generator.
* **Display of long messages in chat.** Fix to automatically collapse long content without needing to refresh the page.
* **Use of images and tools in models.** Adjustments to ensure correct operation in multimodal interactions.
* **Duplicated interface elements.** Fixed duplicated icons in settings menus.
* **Interface and dependency updates.** Fixed inconsistencies that caused failures or unexpected errors.
* **Credit processing.** Fixed conflicts that could cause inconsistencies in the user balance.
## Improvements in chat, permissions, and stability
### New features
* **Access control by permissions and credits.** The use of features like content generation now correctly respects permissions and limits available in the workspace.
### Improvements
* **Drag-and-drop upload in chat.** Updated interface to make file uploads clearer and more consistent.
* **Enhanced chat experience.** New quick actions and better visual organization of long messages.
* **Sending large files.** Greater reliability when working with heavy files in chat.
* **Consistency in workspace selection.** Adjustments to ensure the displayed environment matches the selected one.
### Fixes
* **Chat message field.** Fixed visual cuts and limitations when typing long content.
* **Tool selection.** Resolved an issue that prevented unselecting tools after the first interaction.
* **Scrollable forms.** Fix to allow proper navigation on screens with many fields.
* **File generation.** Resolved a freeze that caused indefinite loading.
* **Insufficient credits.** Fixed inconsistent behaviors and loops when reaching the limit.
* **Price display on mobile.** Adjusted incorrect values when navigating between plans.
## Searchable connectors, chat cloning with attachments, and fixes
### New features
* **Searchable connectors list.** The connectors panel now has a live search with incremental loading so you can find the right connector faster, even when you have many integrations connected.
* **Clone chat with attachments.** You can now optionally include attached documents when cloning a shared chat, so the full context is preserved in the copy.
### Bug fixes
* **Copy button on code blocks.** The copy button was missing on monospaced code blocks in chat. It is now visible and working again.
* **Login and sign-up pages in light mode.** These pages were incorrectly inheriting dark mode styles. They now always render in light mode.
## AI employees, credit cycle alignment, and chat fixes
### New features
* **Cancel in-progress agent runs.** You can now stop a digital employee run that is still in progress directly from the run history, without waiting for it to finish.
* **Rehire terminated AI employees.** Browse and restore AI employees you previously terminated via the new "Open for Work" option in the Deploy menu.
### Bug fixes
* **Credit cycle aligned to your billing date.** Credit cap windows now follow your subscription's actual billing dates instead of calendar months, ensuring caps and renewals match your real billing period.
* **Wallet loads instantly.** The wallet icon was spinning indefinitely for many users. The credit usage panel now loads quickly on every account.
* **Files stay when you edit a message.** Attached files and tool selection were being cleared when editing a chat message. Both are now preserved when you edit and resend.
* **Usage history privacy.** Links to private chats in usage history were accessible to unauthorized viewers. Private executions are now correctly hidden from users who do not have access.
## Cowork canvas in React, digital employee actions, and reliability fixes
### New features
* **Cowork canvas rebuilt in React.** The LLM canvas in Cowork has been migrated to React Flow, improving rendering performance and responsiveness during complex multi-agent interactions.
* **Digital employees interact with external tools.** Agents can now validate and process external action requests, enabling tighter integration with third-party services during autonomous runs.
* **Memory role-gated access.** Memory collection grants now support a minimum membership role, giving workspace managers finer control over who can access shared memory.
### Improvements
* **Agent Studio tag filtering.** Tag-based filtering in the Agent Studio catalog now works correctly, making it easier to browse and find agents by category.
* **Wallet usage label.** The wallet now shows the correct calendar month label for monthly usage, removing a confusing mismatch.
### Bug fixes
* **Scheduler next-run timing.** Scheduled agent runs were drifting from their expected times. Next-run is now stored and computed correctly.
* **Account deletion error.** Deleting an account was failing with a generic error for all users. This has been fixed.
## Secret invite links, no-tools mode, connectors view-only, and Spaces fixes
### New features
* **Secret invite links.** Workspace members can now be invited via a private link. Accepting a secret link automatically removes any duplicate pending email invitations for the same user.
* **No-tools mode.** Admins can now lock the tool selection for an agent to "no tools," and the chat UI clearly communicates when tool selection is restricted by the workspace configuration.
* **Connectors view-only mode.** Users without permission to manage connections now see the connectors panel in read-only mode rather than encountering an error.
* **Loading indicator on workspace switch.** A visible loading state now appears when switching workspaces, preventing accidental duplicate clicks.
### Bug fixes
* **Spaces cross-workspace file leak.** Files from other workspaces were incorrectly appearing in the Spaces personal files list. This is now fixed.
* **Provider quota errors in chat.** When an AI provider returns a quota failure mid-stream, the error is now handled gracefully instead of causing a blank or stuck response.
* **Connector OAuth sync after popup close.** Closing the OAuth popup after selecting an account was not completing the connection. The sync now finishes correctly.
## Billing and renewal reliability
### Bug fixes
* **More reliable credit renewals.** Duplicate renewal prevention and late-cycle backfilling now work correctly, ensuring credits are granted on time without blocking subsequent cycles.
* **Coupons applied with correct duration.** Promotional coupons were being applied indefinitely in some cases. They now expire as intended and are correctly resolved across accounts.
## Workspace Artifacts, API Playground billing awareness, and more
### New features
* **Workspace Artifacts.** Admins can now manage published artifacts directly from workspace settings — filter, paginate, and toggle publish/unpublish with full permission controls.
* **API Playground billing awareness.** The playground now warns you before a generation that may count against your billing limits, so you can decide before any charges apply.
* **Advanced settings multi-select.** Fields in the Advanced Settings panel now support selecting a subset of options, giving you finer control over agent configuration.
* **Pending workspace invitations.** Admins can now see pending invitations alongside active members and the add-member panel prevents duplicate invites.
### Bug fixes
* **More reliable subscription renewals.** Some subscriptions were failing to renew correctly in specific billing-cycle timing scenarios. Your plan now renews as expected.
* **Signup on iOS Safari.** The email step of the signup modal was broken on iOS Safari. This is now fixed.
## Workspace teams, digital employees, MCP plugins, and connectors
### New features
* **Workspace Teams.** Group workspace members into teams, assign team-level memory settings, and control which agents and tools each team can access.
* **Digital Employees.** Agents can now run on a schedule, wake on events, wait for human approval on specific steps, and leave a visible activity trail — all within spending limits you define.
* **MCP Plugins.** Workspaces can register trusted external tool servers. Agents in chat and autonomous runs can invoke those tools directly.
* **Connectors dropdown in React.** The connectors selector in the chat input area is now built in React for a faster and more consistent experience across the platform.
### Bug fixes
* **Chat history context budgeting.** Isolated message tokens are now used for history budgeting, preventing context overflow in long conversations.
* **Mobile chat and menu.** Several mobile layout issues in the chat interface — bottom sheets, tool tooltips, and menu rendering — have been resolved.
* **Subscription renewal timing.** An edge case where the billing cycle anchor caused renewal failures due to a Stripe API change has been fixed.
## Custom workspace roles and private agent governance
### New features
* **Custom workspace roles.** Workspace managers can now create, edit, and delete custom roles with specific permission sets tailored to their team's needs — such as a content reviewer with restricted access.
* **Private agents and results.** Agents and their outputs can now be set to private. Only authorized members can view private agents or access their results, with a clear experience when access is denied.
### Bug fixes
* **Skills slash command restricted to agent mode.** The skills slash command (/) was accessible in plain chat mode. It is now correctly restricted to agent mode only.
* **Agent type preserved on templates.** The agent type was being reset when saving new templates. It is now correctly preserved.
## Economy Mode, Memory Boost, Skill Library, and chat history filters
### New features
* **Economy Mode.** A new chat setting that reduces the token window to lower credit consumption on longer conversations. The interface shows estimated savings as you adjust the setting.
* **Memory Boost.** Search your full conversation history and select which past context to include in the current chat, with a model picker for the search step.
* **Skill Library.** Skills are now organized by categories with browsable libraries. You can add official skills from the library, preview and edit skill files in the browser, and use slash-command autocomplete to trigger skills in chat.
* **Chat history filter.** The chat sidebar now lets you filter your conversation history by execution origin — Platform or API — so you can find the right conversation faster.
### Bug fixes
* **Embedded chat infinite errors.** Embedded chat streams were failing with repeated errors due to a cross-origin URL issue. This is now resolved.
* **Agent mode context model.** The context model used in agent mode was not resolving correctly in some cases. This has been fixed.
## Multi-agent support, custom credits, and email change
### New features
* **Multi-agent as a native model option.** You can now use multi-agent orchestration directly as a model option in chat, with Smart Components and real-time streaming output.
* **Custom credit purchases.** Pay As You Go users can now enter a custom credit amount, see a live price estimate, and complete the purchase via Stripe checkout.
* **Email change with confirmation.** You can now change your account email address from account settings. A confirmation flow validates the new address before the change takes effect.
### Bug fixes
* **Billing recovery window.** Credits and subscription state are now correctly preserved when a renewal happens shortly after a plan cancellation.
* **Autofill crash on Instagram and Safari.** A browser autofill conflict that caused crashes on Instagram in-app browser and Safari has been resolved.
## Improvements in billing and currency consistency
### Improvements
* **Country and currency settings.** Fixes to ensure users have the correct currency set, avoiding inconsistencies in charges.
## Improvements in agent mode
### Improvements
* **Icebreakers in agent mode.** Fix to ensure the selected model is correctly reflected in the URL.
## Settings redesign and consumption history
### Improvements
* **Model sync in URL.** The selected model is now correctly reflected when navigating between chat modes.
* **Redesigned settings and history.** New interface for personal settings and credit usage view, with better clarity and usability.
## Visibility logic for custom templates
### New features
* **Custom template visibility.** Update to display logic to ensure greater control over how and to whom custom templates are shown.
## Improvements in paywall, chat, and member management
### New features
* **Coupons in paywall.** Adjustments to ensure price changes with coupons are correctly reflected in the interface.
### Improvements
* **Chat streaming stability.** Better error handling and consistency in model display.
* **Member role management.** Adjustments to allow more consistent permission changes in the members table.
## Improvements in API, integrations, and ticket management
### Improvements
* **Enhanced ticket management.** Improvements in querying and organizing tickets for greater operational efficiency.
* **Removal of image editing integration.** Platform simplification by removing unused components.
* **More consistent model configuration.** Adjustments in the API and platform to align required properties and avoid inconsistencies.
## Improvements in plan upgrade
### New features
* **Improved plan upgrade modal.** Adjustments to display rules and behavior for a clearer experience when changing plans.
## Branding and localization update
### New features
* **Branding and localization.** Visual updates and improvements in multi-language support for a more consistent experience.
## Improvements in modals, files, and chat
### New features
* **Fixed scroll in modals.** Better navigation and usability in platform modal windows.
* **Chat history update.** New chats now appear correctly in history without needing to reload the page.
### Improvements
* **Enhanced file classification.** Better identification of file types and more robust error handling.
* **General dependency updates.** Small adjustments to improve stability and performance.
## Improvements in onboarding, API, and agent mode
### Improvements
* **API Token management.** Fix in token deletion for greater reliability.
* **Smoother onboarding.** Adjustments in timing and transitions for a more pleasant experience.
* **Localization links.** URL updates for more consistent navigation in settings.
* **File handling in agent mode.** Improvements in file upload and processing.
* **Subscription management.** Adjustments in subscription resumption flow.
* **Workspace name.** Fix in saving the workspace name.
* **Agent execution with images.** Fix in image usage to ensure correct association during executions.
## Improvements in chat and fixes with integrations
### New features
* **Embedded chat fixes.** Adjustments to improve embed functionality.
### Improvements
* **Stability in chats with files.** Fixes to prevent failures when files are not correctly associated in certain flows.
## Improvements in onboarding, interface, and dark mode support
### New features
* **Experimental features modal in dark mode.** Visual and usability improvements with full dark mode support.
* **Improved workspace dropdown.** Smoother and more consistent navigation when selecting workspaces.
* **Compatibility updates with external domains.** Adjustments to support integrations and marketing experiences.
### Improvements
* **Onboarding for agent creation.** New more guided and intuitive experience during the initial process.
## Improvements in payments and general adjustments
### New features
* **Improved payment event processing.** Enhancements in reliability and traceability of payment-related events.
### Improvements
* **General experience adjustments.** Fixes and refinements in specific flows for greater stability.
## Improvements in agent mode and chat
### Improvements
* **Agent mode in dark mode.** Visual fixes in modals for better consistency in dark mode.
* **Website publishing in agent mode.** Adjustments to ensure publishing works correctly within the flow.
## Affiliate tracking support
### New features
* **Affiliate tracking integration.** Added support to enable proper tracking in external integrations.
## Improvements in agent execution and Agent Studio
### Improvements
* **Agent execution and playground.** Fixes to prevent improper failures during executions.
* **Cleaner Agent Studio.** Non-relevant fields are no longer displayed, making configuration simpler and more intuitive.
## More robust history export
### New features
* **CSV history export.** Improvements to prevent timeout failures when exporting large volumes of data.
## Improvements in showcase chat and paywall conversion
### New features
* **Attachment indicators in showcase chat.** The chat now displays visual indicators for attached files, with a better experience on mobile devices.
* **Paywall conversion experience.** Adjustments to make the journey for non-subscribed users clearer and more efficient.
## Adjustments in plans and overall experience
### New features
* **Improved language settings.** Enhancements in language definition and consistency in external integrations.
## New agent mode and reliability improvements
### New features
* **New agent mode component.** Introduction of a new dedicated experience for interactions with agents.
### Fixes
* **Error logging improvements.** Adjustments in error tracking for greater visibility and reliability.
## Improvements in billing and subscription management
### New features
* **Adjusted access to billing modal.** Better control of display for users with different permissions.
* **Scheduled cancellation.** Ability to schedule cancellation for a future date with automatic charge suspension.
### Improvements
* **Redirect links in history.** Adjustments to make redirects more consistent and reliable.
## Adjustments in collection retrieval
### Fixes
* **Collection loading limit.** Fix in collection query limit to ensure stability and proper performance.
## Improvements in payments and memory
### New features
* **Subscription price range.** Support for displaying price ranges on the plans screen, providing more clarity to the user.
* **Expanded memory collection loading.** Increased limit of retrieved collections to improve access to stored data.
## Improvements in onboarding and voice selection
### New features
* **Improved voice selection in chat.** Enhancements in choosing and configuring voices within chat.
## Adjustments in tool selector and chat improvements
### New features
* **Tool selector adjustment.** The selector has been simplified to avoid redundant display when multiple tools are available.
* **Translation improvements.** Enhanced handling to ignore keys composed only of numbers.
* **Unified model resolution.** Update to model selection logic for greater consistency between chat and video components.
### Improvements
* **Share button in chat.** Fix in displaying the share button when starting a new conversation.
## Improvements in plans experience and retrospective
### New features
* **Plan display in paywall.** Unconfigured plans no longer appear in the carousel, making the experience clearer.
* **Adjustments in 2025 retrospective.** Improvements in texts and messages for greater clarity and consistency.
## Improvements in chat and member invites
### Improvements
* **Long session alert with dismiss.** You can now dismiss long session alerts directly in chat.
### Fixes
* **Member invites on mobile.** Adjustments in modal width and improvements in the experience on mobile devices during invite sending.
## Adjustments in vision model billing
### Improvements
* **Vision model billing in chat.** Adjustment in consumption calculation for lite users, ensuring greater accuracy in usage accounting.
## Improvements in chat, subscription page, and general adjustments
### New features
* **Improvements in WhatsApp interaction.** Adjustments in button behavior in promotional experiences to make navigation more consistent.
### Improvements
* **Voiceover flow in charges and refunds.** Adjustments to make the process clearer, especially in scenarios with prepaid credits.
* **Long conversation warning in chat.** Fix for improper persistence of the warning when starting a new chat.
* **Clearer subscription page.** Improvements in communication and presentation of plan information.
* **Plan naming updates.** References to previous campaigns have been standardized to current plan names.
### Fixes
* **Credit purchase modal.** Fix in image display and error handling during the purchase process.
## 2025 retrospective and preparation for Chat V2
### Improvements
* **2025 retrospective.** New interactive experience that presents statistics, achievements, and usage milestones of users and teams throughout 2025.
# Using the Chat
Source: https://docs.tess.im/en/chat
Tess Chat is the materialization of our vision for collaboration between AI models. Think of the Chat screen as your command center.
In the same interface and within the same conversation, you can switch between text models (LLMs), image, video, audio, voiceover, avatar creation, and also use other professional tools for data analysis, document creation, integrations, etc.
In other words, in a natural and fluid way, you can have hundreds of models collaborating with each other, which greatly increases your AI performance.
In this space, besides sending your messages to the chat and talking with the AIs, you can:
1. **Select the LLM**: Choose the ideal AI model for each task or leave it in Automatic mode so Tess can decide for you. Models are grouped in the picker (by provider/family) so you can scan faster — for example Gemini Flash, Claude Sonnet, Nemotron, and media tools stay easier to find.
> **Screenshot placeholder — model picker groups:** Capture the LLM selector open with **grouped sections** visible (provider/family headers + a few models under each).
2. **Add Knowledge Base**: Feed the AI with your documents and official content to ensure the answers are accurate and aligned with your company.
3. **Enable Tools (Tools)**: Allow the AI to execute actions, such as searching for information on the internet, analyzing data, creating documents, generating images or videos, or interacting with other apps.
4. **Integrate Connectors:** This function creates a more operational layer for chats and agents; with it, your work goes beyond just conversational and starts triggering actions in external spaces such as platforms you use daily.
5. **Adjust the Temperature**: Control the level of creativity in the responses. Lower values (systematic, objective) generate more direct and factual answers, while higher values (creative, imaginative) allow more freedom and creativity. This matters to reduce the risk of hallucinations.
6. **Use Memory Collections**: Organize and activate sets of information to create your memories and help personalize responses and keep consistency over time.
7. **AI Wallet**: Track your credit balance in real time.
# Knowledge Base
Source: https://docs.tess.im/en/chat/kb
In Tess chat, you can attach files to provide context and “train” the conversation, meaning allowing Tess to use that content to respond better. There are two ways to send files in the chat: quick upload (drag/paste) and advanced upload (via the “+” button), which unlocks important processing settings.
When you attach a file to the chat, Tess can process and use that content as a base to:
* answer questions about the content of the file
* summarize, extract data, and create outputs from the material
* keep the context of the interaction (especially useful for support, onboarding, and projects)
In addition, the full history of uploads and usage of these files can be viewed in the Knowledge Base within Settings.
Keep in mind that when you add a document to the Knowledge Base of a conversation, only that conversation will be trained with the document in question. If you start a new chat, you’ll need to attach the file again. \
\
To avoid rework, if it’s a repetitive task, we recommend creating an agent and attaching the file to the agent’s Knowledge Base (not the chat), so every conversation started in that agent will already be trained with the document that is part of your Knowledge Base.
## Two ways to send files (and the difference between them)
You drag the file into the chat, or paste (Ctrl+V) when applicable. It’s the fastest way to attach something and continue the conversation.
After it’s sent, it will appear at the top of the chat, training definitively when the message is sent together with the file:
* Limitation: It usually doesn’t let you choose advanced processing options. In other words, you attach it, but you don’t control the file processing (RAG or Deep Learning).
* When to use: When you just need to attach something quickly and don’t need settings (e.g., a simple image, a CSV, a text-based PDF, a link).
In the chat, click the “+” button (tools/attachments) next to the message box. Then, select the file upload/attachment through that path. This way, you can choose the processing type before sending (depending on the file) and enable specific settings by file type.
On this screen, you can also drag the file or select it from your computer. When you attach a file, it will appear on the right side, and in the little arrow you can expand the available settings (when applicable):
### You can configure, for example:
**A) Processing type between RAG and Deep Learning**
* RAG (retrieval): focuses on fetching relevant excerpts from the file to answer questions based on the content. Uses fewer credits.
* Deep Learning: focuses on deeper processing of the content, depending on the file type and the available feature. Uses more credits.
**B) Specific settings by file type, for example:**
* **PDF:** You can choose how the PDF will be interpreted, for example:
* Text processing: ideal when the PDF is made of selectable text.
* OCR: ideal when the PDF contains any image, or is scanned and the AI needs to “read” text from text and images.
* **MP3 and MP4:** You can configure transcription parameters, for example:
* Language: helps the transcription be more accurate (especially in PT-BR, EN, ES, etc.).
* Transcription AI/model: choose between Deepgram, Assembly, Open AI, and Rev AI.
You can track everything that was sent to Tess (including uploads made in the chat) in the Knowledge Base under Settings.
Each document added to the Knowledge Base implies consuming a low volume of credits to perform this task.
# Claude Fable 5 (Anthropic)
Source: https://docs.tess.im/en/claude-fable-5
The Claude Fable 5 is an advanced AI model by Anthropic, designed for complex reasoning tasks, long-form content generation, and deep contextual analysis. It stands out in scenarios that require narrative consistency, interpretation of large volumes of information, and more “structured” responses.
It is ideal for users who need high quality — but requires special attention to credit consumption and data retention.
| **Model ID**
Frontier |
Claude Fable 5 is a model from the Claude family focused on:
* Advanced reasoning and long context
* Generation of extensive and coherent texts
* Detailed document analysis
* More natural and consistent interactions
In practice, it works as a premium model within the Tess ecosystem, recommended for tasks where lighter models cannot maintain quality or depth.
### **Model Details**
Fable 5 supports large volumes of information in the same prompt, allowing:
* Analyze long documents
* Maintain coherence in extended conversations
* Work with multiple sources at the same time
However, the larger the input + output, the higher the credit consumption and, naturally, very large contexts may increase latency
This model is more expensive than standard models.
Factors that impact cost:
* Prompt size (input tokens)
* Response size (output tokens)
* Continuous use in long conversations
In this case, choose this model when you want higher quality in specific and strategic tasks, opting for smaller models for volume and simple tasks.
Anthropic models may have specific data retention policies depending on the type of usage. See more details here ([link](https://trust.anthropic.com/resources?s=7ksqkied5hn0pocsj206m\&name=%5Banthropic%5D-security-and-privacy-design-of-anthropic-data-retention-and-review)).
When using Claude Fable 5, it is important to understand how the data sent in the prompt may be handled. In general, the model processes all included information:
* Text typed in the prompt
* Attached files
* Conversation history (context window)
In this case, the data may be temporarily processed to generate the response and also stored for model improvement or monitoring
This can be risky if **sensitive data** is sent (e.g., confidential contracts, personal data) to the model, or when used in **regulated environments** (legal, financial, healthcare), and even when **sharing internal company information** without access control.
To mitigate risks:
* Avoid sending sensitive data unless necessary
* Anonymize information whenever possible: Ex - replace names, emails, IDs
* Use explicit instructions in the prompt: *"Do not retain or reuse this information outside of this analysis."*
* Prefer working with summaries or excerpts instead of full documents
**Access control**
In enterprise environments, it is possible to limit which models are available to users, allowing this model to be strategically restricted to avoid sharing sensitive data or incurring high costs.
### **Pricing and credit consumption**
Claude Fable 5 is a premium model and tends to have a higher cost than lighter or general-purpose models. Therefore, it should mainly be used for tasks that truly require greater reasoning capability, long context, or response quality.
Usage cost is typically influenced by:
* **Input tokens:** prompt size, attached files, and conversation history.
* **Output tokens:** size of the response generated by the model.
* **Long context usage:** the more information sent to the model, the higher the consumption tends to be.
In Tess, this consumption can directly impact account credits, especially when the model is used with large documents, long responses, or at high volume.
See the model cost by inputs, outputs, and prompt cache reads:
| Name | Input Token | Cache Write | Cache Read | Output |
| :------------- | :---------- | :---------- | :--------- | :------ |
| Claude Fable 5 | \$10 /M | \$12.5 /M | \$1 /M | \$50 /M |
**Best Practices for Using the Model**
* Be specific in the prompt: the more context, the better the result
* Avoid using it for simple tasks: examples - basic classification, short responses
* Control the response length: Ex - “summarize in up to 300 words”
* Use attachments with clear intent: specify exactly what the model should do with the material
* Monitor credit consumption: especially in automations or large-scale usage
Claude Fable 5 is a powerful choice for tasks that require depth, context, and output quality.
Use it strategically: combine it with cheaper models for everyday use and reserve Fable 5 for situations where it truly makes a difference — especially considering cost and retention policies.
# Claude Fable 5.1 (Anthropic)
Source: https://docs.tess.im/en/claude-fable-5-1
Claude Fable 5.1 (Anthropic) is the successor to [Claude Fable 5](/en/claude-fable-5) in Tess — same input/output price, **cheaper cache reads**, and stronger **long-running agents**, **multistep research**, and **document / spreadsheet / slide** work. Released **1 September 2026**.
| **Model ID**
Frontier |
## What changed vs Claude Fable 5
| | Claude Fable 5 | Claude Fable 5.1 |
| ------------------------- | --------------------------------- | ------------------------------------------------- |
| Focus | Frontier reasoning + long context | Long-horizon agents + knowledge work |
| Context / max output | 1M / 128K | 1M / 128K |
| Thinking | Adaptive (always on) | Adaptive (**always on**, default effort **high**) |
| Knowledge cutoff | Jan 2026 | **Jun 2026** |
| Input → output | Text + image → text | Text + image → text |
| Tess credits / 100 tokens | 0.56 in / 2.80 out | **0.56 in / 2.80 out** (same) |
| Provider cache read | \$1 / MTok | **\$0.25 / MTok** (1/4 of Fable 5) |
Native **reasoning**, **tools**, and **image input**. Anthropic’s public Fable line — reserve it for work that still falls short on lighter Claude models.
Anthropic classifies Fable 5.1 as a **Covered Model**: extra retention and safety review on the provider side. Follow the [Tess Privacy Policy](https://tess.im/page/privacy-policy) and [Anthropic’s retention guidance](https://trust.anthropic.com/resources?s=7ksqkied5hn0pocsj206m\&name=%5Banthropic%5D-security-and-privacy-design-of-anthropic-data-retention-and-review). Don’t send secrets, credentials, or regulated personal data unless the task needs them.
## Pricing (Tess credits)
Values follow [Models and Costs](/en/models-and-cost) (credits per 100 tokens). Same input/output as Fable 5 — Anthropic did not change headline rates:
| Model | Input / 100 tokens | Output / 100 tokens |
| ---------------- | ------------------ | ------------------- |
| Claude Fable 5.1 | 0.56 | 2.80 |
Long agent sessions that re-read a cached prefix are cheaper on the provider (cache reads at a quarter of Fable 5). Keep the thread on **5.1** to take advantage of that.
> **Screenshot placeholder — model picker:** Capture the chat model selector with **Claude Fable 5.1** selected.
## Ideal use cases in Tess
1. Long-running coding agents — features across a codebase, review, and performance work that spans many steps
2. Multistep research that has to keep the plan through tool calls
3. Knowledge work on documents, spreadsheets, and slides in one thread
4. Hard reasoning where Fable 5 (or a lighter Claude) still falls short
5. 1M-context sessions without switching models
**Best practices**
* Thinking **cannot be turned off**. Default effort is **high** — don’t use Fable 5.1 as a cheap extractor.
* Prefer **Fable 5** only if you already have a working flow and don’t need the 5.1 agent/research gains; price per token is the same, cache is more expensive on 5.
* Treat long chats as **append-only**. Editing earlier turns can drop or invalidate thinking blocks on the provider.
* Cap response length in the prompt when you don’t need a long deliverable.
See also: [Claude Fable 5](/en/claude-fable-5) · [Models and Costs](/en/models-and-cost) · [Claude Fable 5.1 (Anthropic)](https://platform.claude.com/docs/en/models/fable-5-1/overview).
# Concepts
Source: https://docs.tess.im/en/concepts
Learn the essential concepts that will help you get the most out of Tess.
Think of AI Agents as your specialized virtual assistants. Each agent is an AI trained to perform specific tasks, such as analyzing documents, generating reports, creating creative content, or managing your interactions with customers. You can create an agent with a simple prompt so that it systematically performs any task.
Tess Agent Computer is an autonomous general AI agent built to complete tasks and deliver results end to end. With a single prompt, you can run entire workflows — from market analysis and spreadsheet creation to building websites, dashboards, and much more. Far beyond a simple chatbot, Tess Agent actively plans, executes, and delivers the complete output with exceptional quality.
An AI model is a type of system designed to create new content — text, images, videos, audio, and more — based on parameters that were provided to it during its training. Examples of models include ChatGPT, Google Gemini, Claude Sonnet, etc. Unlike traditional AI models, which only recognize patterns or classify information, generative models can produce something new and original, simulating human creativity.
Agent Studio is your agent creation environment in Tess. This is the area of the platform where you can build, customize, and manage your own AI Agents. In Agent Studio, you build prompts, define models, the level of privacy, the knowledge base, and the tools your agents will use.
Tools are resources that you can add to your AI Agents or to the Tess chat itself to further enhance performance. They allow agents to perform specific actions, such as searching for information on the internet and on social media, creating images and documents, analyzing data in spreadsheets, and much more.
The Knowledge Base is the information repository that you provide to your AI Agents or add directly in the chat to improve their training and make them more accurate. You can upload documents, spreadsheets, images, add website URLs, and other materials so that your agents or your conversations can learn about a specific topic. A well-structured knowledge base maximizes the accuracy and reliability of the answers.
Memories allow AI Agents to learn from past interactions. They work as a record of relevant and reusable snippets from previous conversations, which can be saved and organized into collections, ensuring that the AI remembers the context and your preferences over time. This feature makes future interactions more personalized and efficient. You can decide at any time which memories will be active or inactive for each conversation.
The Prompt is the instruction you give to an AI Agent or to the model used directly in the chat. It is how you "ask" or "request" that it perform a task. The clarity and quality of your prompt are essential to obtain the best results. A good prompt is specific, contextualized, and clear about the expected outcome.
Your Credit Wallet is the control center for your usage in Tess. Each plan has a certain amount of credits that is deposited into your AI Wallet for you to use as you wish within the platform.
Each action performed on the platform consumes credits, and the amount of credits may vary depending on the complexity of the task and the AI model used. More advanced models and features such as Max Mode, for example, consume more credits.
You can check your balance and usage history at any time directly on the platform, ensuring full transparency and control over your investment. Managing the AI Wallet is the responsibility of the user.
Tess's Marketplace is the largest collaborative AI space on the planet, where users can discover, buy, and sell AI Agents through the monetization features mentioned above.
The Marketplace works as a large showcase of ready-made solutions for the most diverse challenges and industries, creating a win-win situation for users: on one hand, creators can leverage their skills and earn money; on the other hand, new users have the opportunity to find useful agents for their work and start using them right away, increasing the value they capture on the platform.
# Welcome
Source: https://docs.tess.im/en/connectors
Connectors let you turn Tess into a true **execution hub** — where you not only chat with AI, but also access data and perform actions in external tools without leaving the chat.
With them, you can integrate apps that you or your operation already use in your daily routine, such as Gmail, Google Calendar, Notion, Slack, and others, allowing agents and chats to be automated. The result is less manual work, less tab switching, and more fluidity in your workflow.
### **What is it?**
Connectors are native integrations that connect Tess to external applications, enabled when you integrate with the application.
After connecting an app, the AI can use that access within chats and agents to help with tasks such as:
* retrieving information from connected tools;
* organizing operational routines;
* consulting data and documents;
* triggering actions with simple commands;
* reducing context switching across multiple platforms.
The structure of Connectors in Tess is organized into three categories:
1. Apps: ready-made integrations (Gmail, Slack, Notion, etc.)
2. *\[Coming soon]* Custom API: connection to your own APIs or third-party APIs
3. \[Coming soon]Custom MCP: advanced extensions to expand agent capabilities
### **Where to find it and how to use it?**
You can access Connectors directly from the chat or on the agent editing screen:
* Click the + in the lower-left corner of the chat box
* Select Connectors
* And click “Add connectors” to add new ones or
* “Manage connectors” to manage existing connections
* Locate the desired application.
* Click Connect to start authentication and confirm all permissions in the modal that opens
* Open Agent Studio and locate the desired agent to adjust, or create a new one
* Find the Connectors button
* To allow use in the agent, keep the gear enabled.
* If you want the end user to also choose whether to use it, keep "User decision" enabled. In this case, you will not be able to choose which connector will be used, as that will be up to the end user
* However, to add the specific connectors the agent will use, you will need to uncheck the user decision option and manually add the connectors.
* Click add to integrate new connectors or manage, if you already have them and want to adjust something
* Locate what you want and proceed with the permission grants
### **Understanding the proposal**
Connectors expand Tess's role within the Workspace. Instead of acting only as text generation or analysis in the chat, the AI starts interacting with connected external systems.
In other words, it goes from assistant to task operator, and this is especially relevant in agents, where behavior can be structured to use connectors automatically within flows.
* the chat stops being only conversational and becomes actionable;
* agents can work with context coming from external tools;
* simple commands can become practical tasks within the workflow.
In practice, this means Tess can function as a single interface between user, context, and execution.
A simple way to understand it:
* **without Connectors:** the AI guides you on what to do;
* **with Connectors:** the AI also helps do it.
### **Practical examples**
Below are some usage examples that help show the value of the feature in day-to-day work.
1. **Gmail**
It can be very useful for retrieving and organizing information from emails; summarizing conversations; and locating important emails.
> *Example prompt:*
>
> 1. *"Look for the most recent emails about contract renewal and bring me a summary with the main points, responsible parties, and next steps."*
> 2. *"Find unread messages from client XYZ and organize them by priority."*
> 3. *"Check my last 20 emails in Gmail, identify the ones that need an urgent response, and write professional replies for each one. Show them to me before sending."*
**2. Google Calendar**
It allows you to check your schedule; find appointments; and support meeting organization.
> *Example prompt:*
>
> 1. *"Check my appointments this week and highlight free time slots for a 30-minute meeting."*
> 2. *"List the upcoming events related to enterprise clients by looking for events with \[EN] in the title."*
> 3. *"Look at my schedule for tomorrow in Google Calendar and reorganize appointments to prioritize sales meetings. If there are conflicts, suggest new free time slots on the same day."*
**3. Google Sheets**
It makes it possible to consult spreadsheets; cross-reference operational data; and structure reports quickly based on the collected data.
> *Example prompt:*
>
> 1. *"Analyze the leads spreadsheet and tell me which contacts have had no follow-up in the last 7 days."*
> 2. *"Read the monthly metrics spreadsheet and generate an executive summary with the main deviations."*
> 3. *"Read this spreadsheet and identify usage drop patterns over the last 30 days."*
**4. GitHub**
It enables consultation of the GitHub repositories you have access to; supports monitoring technical activities; and is useful for supporting product and engineering teams.
> *Example prompt:*
>
> 1. *"List the most recent pull requests in the project and summarize the purpose of each one."*
> 2. *"Look for issues related to the 'xxxx' integration and organize them by priority."*
> 3. *"List the latest open PRs in the GitHub repository and summarize what changed."*
**5. Slack**
You can consult channel or direct messages; summarize discussions in a group; and locate decisions in channels.
> *Example prompt:*
>
> 1. *"Summarize what was discussed in the product channel today and highlight decisions, pending items, and responsible parties."*
> 2. *"Look for messages about connectors or integrations and consolidate the team's main feedback."*
> 3. *"Send a message in Slack to the #marketing channel saying the live starts in 10 minutes."*
### **Best practices**
To get better results with Connectors, follow these recommendations:
1. **Be specific in the prompt:** Instead of writing “check my emails,” prefer: “Look for emails from the last 2 weeks with the subject renewal and summarize the main points.”
2. **State the objective of the task:** Explain the expected result, such as: summarize; list; compare; organize; identify pending items; suggest next steps.
3. **Use clear filters:** Whenever possible and applicable, inform: period; project; client; channel; document; priority.
4. **Test first with simple tasks:** Start with queries and summaries before depending on more complex flows.
5. **Structure agents with focus:** If the connector will be used in an agent, make its role clear in the training and what you expect from using the connector input or what you want to use for some action. Example: support agent; sales agent; operations agent; data analysis agent.
6. **Review permissions carefully:** Connectors involve access to external systems. Although your data is secure and not used in model training, try to connect accounts and apps that are appropriate to the usage context.
If you already use Tess in your day to day, this is one of the most important features for bringing AI closer to your real workflow.
With this, it is possible to understand how Connectors transform Tess into a more practical work layer, connecting conversation and execution in the same place. With them, chats and agents start interacting with external tools and help the user consult information, organize routines, and perform actions with much less friction.
# Open & Manage Documents
Source: https://docs.tess.im/en/cowork/artifacts/artifact-management
Preview, download, and organize files from document nodes and the employee drawer
## Overview
You manage deliverables where they appear in Cowork — **document nodes** on the Mesh Canvas and the **Files** section in an employee’s drawer. There is no standalone file browser app.
## Open a document from the mesh
1. Find the **document node** (orb) on the Mesh Canvas — usually near the employee or squad that created it.
2. Click the node to open the preview.
3. From the preview you can:
* Read or skim content
* **Download** the current version
* Browse **version history** and open or restore an older version
## Open files from the employee drawer
1. Click an **employee node** on the mesh.
2. In the drawer, open **Files** (or the files section in the run detail).
3. Select a file to preview or download — same version history as mesh nodes.
Squad files also open from the **Squad panel** → shared working document or linked files.
## Organize with folders
Files can carry a **folder path** for grouping (for example squad working documents often live under a `Squads/` path). Consistent naming across your team makes related documents easier to spot in the drawer list.
## Download and versions
* **Download** always pulls the version you are viewing.
* Before assuming a file is stale, check **version history** — a newer version may already exist from a later run.
## Tips
* Pin important document nodes mentally by employee color and name — the canvas can get crowded
* After a squad run, open the **working document** first, then drill into individual member files if needed
* Use [scope changes](/en/cowork/artifacts/scope-hierarchy) when the whole team needs access, not repeated one-off sends
## Next steps
* [Documents overview](/en/cowork/artifacts/artifacts-overview)
* [Scope hierarchy](/en/cowork/artifacts/scope-hierarchy)
* [Sharing documents](/en/cowork/artifacts/artifact-sharing)
## Other languages
* [Português (BR)](/pt/cowork/artifacts/gerenciamento-artifacts)
* [Español](/es/cowork/artifacts/gestion-artifacts)
# Sharing Documents
Source: https://docs.tess.im/en/cowork/artifacts/artifact-sharing
Share files with teammates, squads, and specific people from the mesh or drawer
## Overview
Share deliverables from the document preview or employee drawer — either by **widening visibility** (team, workspace, squad) or by **granting a specific person** view or edit access.
## Share with a squad
The fastest way to collaborate on an initiative:
1. Add the file to the **Squad** (or create it inside the squad run — the working document does this automatically).
2. Every squad member sees the file on the mesh and in the Squad panel.
See [Squads fundamentals](/en/cowork/squads/squads-fundamentals).
## Share with a team or workspace
When a whole group needs access:
1. Open the document from the mesh or drawer.
2. Change **visibility** to **Team** or **Workspace** (when your role allows).
3. Confirm if Tess asks for approval.
See [Who can see a document](/en/cowork/artifacts/scope-hierarchy) for what each level means.
## Share with specific people
When only one or two colleagues need access:
1. Open the document.
2. Add them with **View** (read-only) or **Edit** (can update content).
3. Revoke access anytime from the same sharing control.
Use this when changing squad or team visibility would be too broad.
## When to use which approach
| Situation | Best approach |
| ------------------------------------------------- | ---------------------------- |
| Multi-employee initiative with shared deliverable | **Squad** + working document |
| Entire team should see a report | **Team** visibility |
| Company-wide reference material | **Workspace** visibility |
| One reviewer outside the squad | **Named person** grant |
Squad membership is usually simpler than many individual grants — prefer squads for ongoing collaboration.
## Next steps
* [Who can see a document](/en/cowork/artifacts/scope-hierarchy)
* [Open and manage documents](/en/cowork/artifacts/artifact-management)
## Other languages
* [Português (BR)](/pt/cowork/artifacts/compartilhamento-artifacts)
* [Español](/es/cowork/artifacts/comparticion-artifacts)
# Documents & Outputs
Source: https://docs.tess.im/en/cowork/artifacts/artifacts-overview
How employee deliverables appear as document nodes on the mesh and files in the drawer
## Overview
When Digital Employees finish work, their **documents and files** show up in Cowork in two places you actually use:
1. **Document nodes** on the **Mesh Canvas** — orbs linked to an employee or squad
2. **Files section** in the **employee drawer** — everything that employee produced in its workspace
There is no separate documents browser or Spaces screen in Cowork. You open outputs from the canvas or the drawer.
## What counts as a document
* Reports, spreadsheets, PDFs, code files, images — any file an employee creates or uploads during a run
* A squad’s **shared working document** — the squad’s living deliverable
* **Version history** — each update keeps prior versions you can review or restore
Documents stay linked to the employee (or squad) that created them so you can trace results back to a run.
## Lifecycle
### Created during a run
When an employee completes a task, Tess captures outputs automatically. New files typically start in your **personal** visibility and appear on the mesh near the employee.
### Visible on the mesh
Document nodes sit on the canvas next to the employee or squad that owns them. Click a node to preview, download, or read version history.
### Shared through squads and teams
Move visibility wider when others need access — for example by adding files to a **Squad** (shared with all squad members) or promoting to **team** or **workspace** scope. See [Scope hierarchy](/en/cowork/artifacts/scope-hierarchy).
### Updated over time
Each save creates a new version. Open the document to compare or restore an earlier version.
## Where to look
| Surface | What you see |
| --------------------------- | ---------------------------------------------- |
| **Mesh Canvas** | Document nodes (orbs) for employees and squads |
| **Employee drawer → Files** | All files for that employee |
| **Squad panel** | Shared working document and squad-linked files |
## Tips
* Use clear names when employees ask you to rename outputs — it speeds up search on a busy canvas
* If you expect a file and do not see it, open the employee drawer and check the latest run in the timeline
* For squad work, start with the **working document** before hunting individual member files
## Next steps
* [Open and manage documents](/en/cowork/artifacts/artifact-management)
* [Scope hierarchy](/en/cowork/artifacts/scope-hierarchy)
* [Sharing documents](/en/cowork/artifacts/artifact-sharing)
## Other languages
* [Português (BR)](/pt/cowork/artifacts/visao-geral-artifacts)
* [Español](/es/cowork/artifacts/vision-general-artifacts)
# Who Can See a Document
Source: https://docs.tess.im/en/cowork/artifacts/scope-hierarchy
Personal, team, workspace, and squad visibility for files on the mesh
## Overview
Every document has a **visibility level** that controls who can open it on the mesh and in drawers. You change visibility when you need to keep a file private, share with a squad, or expose it to a team or the whole workspace.
## Visibility levels
| Level | Who can view | Who can edit |
| ------------------- | --------------------------------- | ------------------------------ |
| **Personal** | Only you (the owner) | Only you |
| **Open space** | Only you (same as personal today) | Only you |
| **Team** | Members of your team | Team managers |
| **Workspace** | Anyone in the workspace | Workspace admins |
| **Squad / project** | Members of that Squad | Squad members with edit access |
Workspace owners and people with company-wide document access can read across levels for oversight — those reads are audited.
## Moving between levels
* **You** can move your own documents among **Personal**, **Open space**, and **Team** when your role allows
* Moving to **Workspace** or attaching to a **Squad** may need approval from an admin or squad owner
* Workspace admins can adjust visibility directly when policy allows
## Squads and shared files
When a file belongs to a **Squad**, every squad member sees it on the mesh and in the Squad panel. The squad’s **working document** is created at squad scope automatically.
Detaching a file from a squad returns it to **personal** visibility for the original owner unless you choose another level.
## Direct sharing with specific people
Sometimes one or two colleagues need access without changing the whole visibility level. You can grant **view** or **edit** access to named users on a document. See [Sharing documents](/en/cowork/artifacts/artifact-sharing).
Documents are not shared via public links or expiring passwords. Access is always through your Tess workspace membership, squad membership, or an explicit grant.
## Next steps
* [Sharing documents](/en/cowork/artifacts/artifact-sharing)
* [Open and manage documents](/en/cowork/artifacts/artifact-management)
## Other languages
* [Português (BR)](/pt/cowork/artifacts/hierarquia-escopo)
* [Español](/es/cowork/artifacts/jerarquia-alcance)
# Real-Time Collaboration
Source: https://docs.tess.im/en/cowork/colaboracao-tempo-real/realtime-collaboration
Teammate presence, follow mode, and live coordination on the Mesh Canvas
## Overview
Cowork is built for teams working on the same **Mesh Canvas**. You see who else is online, optionally share your cursor, and follow a colleague’s view — all inside **Mission Control**, not a separate app.
## Teammate presence
When colleagues open Cowork, their avatars can appear on the canvas so you know who is online.
**Sharing your cursor is opt-in.** By default you neither broadcast your position nor receive others’ live cursors until you turn presence on in settings. Once enabled, teammates in the workspace can see where you are on the mesh.
Use this when pair-reviewing employees, squads, or document nodes together.
## Follow mode
**Follow** lets you watch another user’s Mesh Canvas in read-only mode — you see their employees and layout exactly as they do.
* You can follow someone only if they **enabled presence**
* You must be an active member of the same workspace
* You cannot follow yourself
Follow is useful for onboarding, shadowing a manager’s view, or debugging why two people see different employee nodes (**Cowork Layers** may filter what each person sees).
## Live sync between employees
When one Digital Employee delegates to another, they can enter a **live sync** — a bounded back-and-forth instead of a fire-and-forget handoff.
During sync you see rounds of messages and tool use in the run view. Sessions are time- and round-limited so they cannot run indefinitely. Only one active sync per workspace is typical at a time.
Parent and child share context (connectors, file references mentioned in the task) so the child starts with the same tools the parent already had.
## Related surfaces
| Surface | Collaboration use |
| --------------------------------- | ------------------------------------------------------------------------------------------------------- |
| **Mesh Canvas** | Presence, cursors, shared view of nodes |
| **Employee drawer** | Approvals and input while a colleague watches |
| **Mission Control / Day Planner** | Shared queue of pending items |
| **Squads** | Multiple employees on one initiative — see [Squads fundamentals](/en/cowork/squads/squads-fundamentals) |
## Tips
* Turn presence on only when you want to be visible — it is off by default
* Use **Cowork Layers** to understand why your canvas differs from a manager’s before assuming data is missing
* Resolve **pending approvals** quickly so teammates are not blocked on shared employees
## Next steps
* [Main Interface (Mesh Canvas)](/en/cowork/primeiros-passos/interface-principal)
* [Governance](/en/cowork/digital-employees/governanca/governance)
* [Squads fundamentals](/en/cowork/squads/squads-fundamentals)
## Other languages
* [Português (BR)](/pt/cowork/colaboracao-tempo-real/colaboracao-tempo-real)
* [Español](/es/cowork/colaboracao-tempo-real/colaboracion-tiempo-real)
# Approvals & Human Interactions
Source: https://docs.tess.im/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions
Plan approval, input needed, and connector decisions in the employee drawer and run view
## Overview
Digital Employees can pause a run and ask you to decide. In Cowork those requests appear as cards on the **employee drawer** and on the **live run** view — not in a separate approvals inbox.
Common types:
1. **Plan approval** — review the proposed plan, then Approve or Reject (and edit tasks when the card allows)
2. **Input needed** — answer a question so the run can continue
3. **Connector action** — approve, ask for changes, or skip a connector step
4. **Pending hire review** — for self-hire proposals: Review & Edit / Approve / Dismiss (also surfaced in Mission Control pending items)
## Plan approval
1. Open the employee from the Mesh (or the pending cue in Mission Control)
2. Read the proposed plan in the card
3. **Approve** to continue, or **Reject** to stop
While waiting, the run stays blocked until you decide.
## Input needed
1. Read the question
2. Enter your answer (or pick a choice when offered)
3. Submit — the employee resumes with your input
## Connector decisions
When a run needs approval for a connector action, use the decision card on the run view (approve / ask changes / skip as shown).
## If you do not respond
The run stays waiting. There is no automatic timeout that approves for you. Resolve pending cards so scheduled wake-ups and follow-up work are not blocked.
## Tips
* Clear pending items promptly — Mission Control highlights what is waiting
* Read the plan before approving
* Prefer Supervised Work Mode when you want these gates by default
## Next steps
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
* [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat)
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
# Agent Lifecycle
Source: https://docs.tess.im/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle
Employee status, run outcomes, and actions — invoke, pause, resume, and terminate from the Mesh drawer
## Overview
Every Digital Employee has two related layers of state:
1. **Employee status** — long-lived badge on the Mesh node and drawer (Idle, Active, Running, etc.)
2. **Run status** — outcome of one execution in the timeline (Running, Success, Failed, Awaiting approval)
Monitoring and troubleshooting are easier when you keep both in mind.
## Employee status
| Status | Meaning |
| -------------------- | ---------------------------------------------------------- |
| **Idle** | Created and configured; not scheduled or recently restored |
| **Active** | Enabled — waiting for the next Work Cycle or invoke |
| **Running** | Executing a run now |
| **Paused** | Will not wake on schedule until resumed |
| **Error** | Last run failed — review timeline and run detail |
| **Pending approval** | Blocked on plan, input, connector, or hire review |
| **Terminated** | Decommissioned (fired) — no further scheduled work |
New hires usually start as **Active**. **Idle** often appears after restoring a previously terminated employee.
## Run status (timeline)
Each invoke or Work Cycle wake creates a **run** with its own status:
| Run status | Meaning |
| --------------------- | ------------------------------- |
| **Running** | In progress |
| **Success** | Finished without error |
| **Failed** | Ended with an error |
| **Awaiting approval** | Paused mid-run until you decide |
A run in **Awaiting approval** blocks that run (and can block the next scheduled wake-up) until you resolve the card — see [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions). There is no auto-approve timeout.
“Success” and “Failed” describe a **run**, not the employee. After a successful run, the employee typically returns to **Active**. After failure, it moves to **Error** until the next successful run.
## Actions from the drawer
Open an employee on the Mesh, then use drawer actions:
### Invoke (manual run)
Trigger an immediate run without waiting for the Work Cycle. Status moves to **Running** until the run completes.
### Pause
Stops future scheduled wake-ups. A run already in flight is not forcibly interrupted — pause affects **next** heartbeats.
### Resume
Re-enables scheduling and returns the employee to **Active** (or **Idle** when no cycle is set).
### Terminate (fire)
Decommissions the employee (**Terminated**). Use when the role is no longer needed. Restoring a terminated employee (when permitted) returns it toward **Idle** / **Active**.
Permissions may hide some actions — ask your admin if Invoke or Terminate is missing.
## Scheduled work (Work Cycle)
Employees with a configured Work Cycle wake automatically on that schedule. See [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat).
## Typical transitions
| From | To | Trigger |
| ----------------------- | ---------------- | -------------------------------------- |
| Active | Running | Manual invoke or Work Cycle wake |
| Running | Active | Run succeeds |
| Running | Error | Run fails or stalls beyond recovery |
| Any (except Terminated) | Paused | You pause from the drawer |
| Paused | Active | You resume |
| Any | Pending approval | Hire review or run needs your decision |
| Pending approval | Active | You approve or dismiss as offered |
| Any | Terminated | You terminate from the drawer |
## Tips
* Resolve **Pending approval** and **Error** before scaling headcount
* Pause instead of terminate when work is seasonal — resume when needed
* Use [Execution History](/en/cowork/digital-employees/historico-execucoes/execution-history) to confirm whether failures are one-off or recurring
## Next steps
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Active employees on the Mesh](/en/cowork/digital-employees/visualizacao-ativos/active-agents-view)
* [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat)
# Creating a Digital Employee
Source: https://docs.tess.im/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee
Hire with /hire in the Omnibar or with the full Open position form
## Overview
A **Digital Employee** is an autonomous agent that runs work for your team. In Cowork you can create one in two ways:
1. **`/hire` in the Omnibar** — describe the role in natural language; Tess configures the employee for you (fastest).
2. **Hire → Open position** — the full **Hire** form where you set identity, work instructions, Work Mode, Work Cycle, and Advanced settings yourself.
## Prerequisites
* You are in Cowork (Mesh Canvas)
* Your workspace has credits to run employees
* You can hire Digital Employees in this workspace
## Option A — `/hire` (Omnibar)
### Step 1: Start the command
Click the Omnibar at the bottom of the canvas, type `/hire`, then describe the role — for example: `/hire someone to monitor competitor pricing weekly`.
`/hire` does not open a field-by-field review form before submit. For full control, use **Hire → Open position** instead.
### Step 2: Watch recruiting progress
After you submit, Cowork shows a short recruiting animation while the employee is configured. You cannot edit fields during this sequence.
### Step 3: Employee appears and first run starts
When configuration succeeds, the new employee node appears on the Mesh and the first run usually starts. In Supervised / plan-based modes, you may need to [approve the first plan](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions) in the drawer before real work continues.
If hiring cannot finish confidently, you see a warning instead of a new node — rephrase with clearer tasks, cadence, and constraints.
### What `/hire` typically sets
| Area | Behavior |
| --------------------- | ----------------------------------------------------------------- |
| Name & personality | Inferred from your text, or sensible defaults |
| Goal | Short goal text when your request implies one |
| Work instructions | Expanded operating guide from your request |
| Work Cycle & timezone | Parsed if you mention timing; otherwise a default + your timezone |
| Model | Only if you name a model; otherwise platform default |
| Credits limits | Only if you mention a budget; otherwise none |
| Connectors | Only if your text implies integrations you already connected |
`/hire` does not attach knowledge-base documents you did not imply.
## Option B — Full Hire form (Open position)
1. Click **Hire** → **Open position** (or double-click empty canvas when that shortcut is available).
2. Fill **Identity** (avatar, name, voice, optional Goal).
3. Write **Work instructions** (optional Improve with AI / Add Document; connectors when shown).
4. Choose **Work Mode** (Supervised vs Autonomous) and action approval behavior for connectors.
5. Set **Work Cycle** (Time / Day / Week / Month / Interval / None).
6. Expand **Advanced settings** if needed (personality, timezone, knowledge base, Single Agent / Multi Agent, model, tools, Credits/day, Credits/month, max consecutive failures).
7. Click **Hire**.
For field-by-field guidance later, see [Detailed Configuration](/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration) (same form in Edit Employee).
## After creation
1. Open the employee drawer for status, Goal, schedule badge, and timeline
2. Adjust schedule in **Edit Employee** → Work Cycle — see [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat)
3. Pause / resume / fire from the drawer — see [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
4. Handle approvals in the drawer or run view — see [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions)
## Tips
* Be specific about task, cadence, and constraints in `/hire`
* Prefer the full form when you need an exact model, files, or budget before the first run
* Review the first plan carefully in Supervised mode
* Set Credits/day or Credits/month if cost could grow quickly
## Next steps
* [Work Cycle (schedule)](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat)
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
* [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions)
# Work Cycle (Schedule)
Source: https://docs.tess.im/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat
Set when a Digital Employee wakes automatically using Work Cycle in Hire / Edit
## Overview
**Work Cycle** is the schedule section in the Hire / Edit Employee form. It controls when the employee wakes on its own. Manual runs from the drawer still work regardless of schedule.
## How to configure
1. Open **Hire → Open position** or employee drawer → **Edit**
2. Find **Work Cycle**
3. Pick a cadence (Time / Day / Week / Month / Interval / None — labels as shown in the builder)
4. Set **Timezone** in Advanced settings if needed
5. Save
### None vs scheduled
* **None** — no automatic wake-ups; run only when you (or another trigger) invoke the employee
* **Any other cadence** — Tess computes the next wake-up from your selection and timezone
Pausing the employee (lifecycle) is separate: a paused employee does not run on schedule until resumed. See [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle).
## Where to monitor next wake-ups
* Employee drawer schedule badge
* **Mission Control / Day Planner** on the Mesh for upcoming wake-ups
## Tips
* Leave Work Cycle on **None** while you refine work instructions; invoke manually first
* Match interval length to how long a typical run takes so runs do not stack
* Confirm timezone for distributed teams
## Next steps
* [Execution History](/en/cowork/digital-employees/historico-execucoes/execution-history)
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Detailed Configuration](/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration)
# Detailed Configuration
Source: https://docs.tess.im/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration
Edit Employee form: identity, work instructions, Work Mode, Work Cycle, and Advanced settings
## Overview
There is no separate “detailed configuration” page. Everything lives in the same **Hire / Edit Employee** form used when you choose **Hire → Open position** or click **Edit** on an employee drawer.
Open it from:
* **Hire → Open position** (create)
* Employee drawer → **Edit** (update)
* Review flows that open the same form for approve/dismiss
## Identity
* **Avatar** — upload or pick an image
* **Name** — how the employee appears on the mesh
* **Voice** — voice used for calls when voice is enabled
* **Goal (optional)** — one short text field: what this employee should achieve
## Work instructions
The main operating guide. You can:
* Write or paste instructions
* Use **Improve with AI** when available
* **Add Document** to link knowledge into the instructions
* Select **Connectors** chips when shown
## Work Mode
Choose how tightly a human must stay in the loop:
* **Supervised** — plans and sensitive actions tend to wait for you
* **Autonomous** — more room to proceed without stopping
Also set how **connector actions** behave (automatic vs ask for approval).
## Work Cycle
Defines automatic wake-ups (Time / Day / Week / Month / Interval / None). See [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat).
## Advanced settings
Expand **Advanced settings** for:
| Area | What you set |
| ------------------------------- | ------------------------------------------------------------ |
| **Personality (MBTI)** | Optional personality type |
| **Timezone** | Timezone for the Work Cycle |
| **Knowledge base** | Documents available to the employee |
| **Memory sync** | Whether memory sync is on |
| **Execution mode** | **Single Agent** or **Multi Agent** |
| **Model** | Model used for runs |
| **Search intelligence / tools** | Optional tools and search behavior |
| **Resources** | **Credits/day**, **Credits/month**, max consecutive failures |
Credits limits apply to this employee’s usage. When a daily or monthly limit is hit, further runs are blocked until the window resets (and the employee may pause, depending on policy). Workspace credit balance is separate — an employee over its own limit is still blocked even if the workspace has credits left.
## Saving
* Create: **Hire**
* Edit: **Save changes**
* Review hire: **Approve & save** / dismiss as shown
## Related
`/hire` vs Open position
The optional Goal field
# Model slugs
Source: https://docs.tess.im/en/cowork/digital-employees/configuracao-detalhada/model-slugs
Technical identifiers for AI models used in Cowork JSON imports and programmatic configuration
The **slug** (technical identifier) is the stable value Tess uses to reference an AI model in programmatic configuration — for example, when importing a Digital Employee via JSON in Cowork.
It is different from the **display name** (what you see in the UI, such as "Claude 4.5 Haiku"). In JSON, you use the slug (`claude-4.5-haiku`).
For per-model costs and other slugs, see [Models and Costs](/en/models-and-cost).
## Why this matters in Cowork
When you build or import a Digital Employee **template pack** (JSON), the field that sets the model is `model_override`.
The importer already accepts this identifier: if the value is a model allowed in the target agent's configuration, Tess applies the override correctly. What was missing was publishing these identifiers clearly in the documentation.
## How to use it in Cowork JSON
In the pack (or Autopilot / Digital Employee configuration snippet), set the slug in `model_override`:
```json theme={null}
{
"schema_version": "1.0",
"template_type": "digital_employee_pack",
"autopilots": [
{
"name": "Content Analyst",
"model_override": "claude-4.5-haiku",
"execution_mode": "agent"
}
]
}
```
The slug must exist in the **target agent's** model list (`model` / `agent_model` options). If the value is not available for that agent, the import warns and the override is not applied.
Accepted aliases in the pack: `model_override` or, in some exports, the `model` field with the same meaning.
## How to find the correct slug
Use any of these paths:
1. **Model picker in the UI** — the technical value saved on the employee / agent is the slug (same pattern as the table below).
2. **Export a pack** from a Digital Employee that is already configured — the exported JSON includes `model_override` with the current slug.
3. **Reference table** below — confirmed slugs for common text models.
## Reference table (text models)
| Display name | Slug |
| -------------------------- | ---------------------------- |
| ChatGPT 5.4 | `gpt-5.4` |
| ChatGPT 5.4 Mini | `gpt-5.4-mini` |
| ChatGPT 5.4 Nano | `gpt-5.4-nano` |
| ChatGPT 5.2 | `gpt-5.2` |
| ChatGPT 5.1 | `gpt-5.1` |
| ChatGPT 5 | `gpt-5` |
| ChatGPT 5 Latest | `gpt-5-latest` |
| ChatGPT 5 Mini | `gpt-5-mini` |
| ChatGPT 5 Nano | `gpt-5-nano` |
| Claude 4.6 Sonnet | `claude-4.6-sonnet` |
| Claude 4.6 Sonnet Thinking | `claude-4.6-sonnet-thinking` |
| Claude 4.5 Haiku | `claude-4.5-haiku` |
| Claude 4.5 Haiku Thinking | `claude-4.5-haiku-thinking` |
| Claude 4.5 Sonnet | `claude-4.5-sonnet` |
| Claude 4.5 Sonnet Thinking | `claude-4.5-sonnet-thinking` |
| Claude 4.1 Opus | `claude-4.1-opus` |
| Claude 4.1 Opus Thinking | `claude-4.1-opus-thinking` |
| Claude 4 Sonnet | `claude-4-sonnet` |
| Claude 4 Sonnet Thinking | `claude-4-sonnet-thinking` |
| Claude 4 Opus | `claude-4-opus` |
| Claude 4 Opus Thinking | `claude-4-opus-thinking` |
| Claude 3 Haiku | `claude-3-haiku` |
| Gemini 3.1 Flash Lite | `gemini-3.1-flash-lite` |
| Gemini 2.5 Pro | `gemini-2.5-pro` |
| Gemini 2.5 Flash | `gemini-2.5-flash` |
| Gemini 2.0 Flash | `gemini-2.0-flash` |
| Gemini 2.0 Flash Lite | `gemini-2.0-flash-lite` |
| Consensus | `consensus` |
| Kimi K2 | `kimi-k2` |
| Tess 5 | `tess-5` |
| Tess 5 PRO | `tess-5-pro` |
| Tess AI Light | `tess-ai-light` |
| Llama 4 Maverick | `llama-4-maverick` |
| Llama 4 Scout | `llama-4-scout` |
Availability depends on your plan, team/workspace policies, and the models enabled on the agent. Newer models follow the same slug pattern (lowercase, hyphens, and dots for the version — for example `claude-4.5-haiku`).
## Related
Model field in Advanced settings
Lowest possible execution cost per model
# Defining Agent Goals
Source: https://docs.tess.im/en/cowork/digital-employees/definicao-de-objetivos/defining-goals
Set the optional Goal field so a Digital Employee keeps a clear purpose
## Overview
A **Goal** is an optional one-line purpose for a Digital Employee. In the Hire / Edit form it appears as **Goal (optional)** under Identity — a single text field (for example: “Monitor competitor pricing and summarize weekly”).
There is no multi-field goal form in the UI (no separate description / success criteria / progress notes editors). Progress and run detail show up in the employee drawer timeline after runs.
## How to set a Goal
1. Open **Hire → Open position**, or open the employee drawer → **Edit**
2. In **Identity**, fill **Goal (optional)**
3. Save with **Hire** or **Save changes**
Keep it short and outcome-oriented. Detailed procedures belong in **Work instructions**, not in the Goal field.
## Where you see it later
* Employee **detail drawer** shows the goal near status and schedule
* Runs continue to use work instructions as the operating guide; the Goal is the persistent “why”
## Tips
* Prefer one concrete outcome over a long paragraph
* Put steps, tools, and edge cases in Work instructions
* Update the Goal when the employee’s mission changes — use Edit Employee
## Next steps
* [Detailed Configuration](/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration)
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
* [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions)
# Governance
Source: https://docs.tess.im/en/cowork/digital-employees/governanca/governance
Who sees which employees on the mesh, manager hierarchy, and oversight on Cowork
## Overview
As Digital Employees spread across a workspace, governance answers: **who can see and manage whom**, **how delegation hierarchies appear on the mesh**, and **what evidence exists when something changes**.
Cowork surfaces governance through the **Mesh Canvas**, **Cowork Layers**, and employee drawers — not through a separate admin console inside Cowork.
## What you see on the mesh
### Cowork Layers
The **Cowork Layers** control (action bar on Mission Control) filters whose employees appear on your canvas:
* **My area** — employees you own
* **Direct reports** — employees owned by people who report to you (when you are a manager)
* **Their employees** — extend down the org tree as your role allows
* **Full org** — broadest view for workspace leaders
If you and a colleague see different nodes, check Layers before assuming an employee is missing.
### Employee hierarchy
A Digital Employee can **delegate** to other Digital Employees — a parent with subagents on the mesh, not a flat list.
Practical limits you will hit in the product:
* Delegation depth is shallow (a subagent cannot spawn its own subagents)
* Each orchestrator supports a bounded number of subagents
When a parent delegates, it may open a **live sync** with the child instead of a one-shot handoff. See [Real-time collaboration](/en/cowork/colaboracao-tempo-real/realtime-collaboration).
Subagents appear nested under their parent in views that show hierarchy; open each node’s drawer for its own runs and files.
## Manager and admin oversight
**Workspace owners** and people with **manage** access can configure employees they are allowed to see, pause or resume them, and adjust budgets and connectors.
**Run history and documents** respect the same visibility: you only open drawers and files for employees in your allowed Layers view unless you have broader workspace oversight.
Company **Members and Permissions** (outside Cowork) controls who can hire, invoke runs, view all employees, or read every document. Tess applies those rules automatically on the mesh — there is no second permission screen inside Cowork.
To change who can hire, manage teams, or access features, use your workspace **Members and Permissions** settings in Tess.
## Audit trail
Important actions — creating or pausing an employee, starting or completing runs, budget warnings, squad membership changes — are recorded in Tess’s **activity log** asynchronously. Admins use this for compliance and troubleshooting; day-to-day users feel it as reliable history in employee timelines and workspace audit exports when enabled.
## Tips
* Align **Cowork Layers** with your role before reviewing a teammate’s canvas in **Follow** mode
* Keep orchestrator teams small — delegation is powerful but adds monitoring surface
* Use **Mission Control / Day Planner** to catch pending approvals across everyone you manage
## Next steps
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Real-time collaboration](/en/cowork/colaboracao-tempo-real/realtime-collaboration)
* [Detailed configuration](/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration)
## Other languages
* [Português (BR)](/pt/cowork/digital-employees/governanca/governanca)
* [Español](/es/cowork/digital-employees/governanca/gobernanza)
# Execution History
Source: https://docs.tess.im/en/cowork/digital-employees/historico-execucoes/execution-history
Review past runs from the employee drawer timeline and open full run detail for logs, cost, and outcomes
## Overview
**Execution history** is the record of every run (Work Cycle wake-up or manual invoke) for a Digital Employee. In Cowork you browse it from the employee **detail drawer** — not from a standalone history app.
## Open the timeline
1. Click the employee on the Mesh Canvas
2. In the drawer, find the **Timeline** (or recent runs list)
3. Each row shows status, start time, duration, and credits used when available
Runs appear newest first. Status labels include **Running**, **Success**, **Failed**, and **Awaiting approval**.
## Open run detail
Click a run in the timeline to open its full detail view:
* **Outcome** — success, failure, or still in progress
* **Wake reason** — scheduled heartbeat vs manual invoke
* **Duration and credits** — how long it ran and what it cost
* **Logs and result excerpt** — what the employee did and produced
* **Approval history** — plan or input steps when the run paused for you
Use run detail to debug failures, verify deliverables, and understand credit spend per execution.
## Filter and paginate
When many runs exist, the timeline loads in pages. You can narrow by run status (for example, show only failed runs) when the drawer offers filters.
There is no free-text search or date-range picker in the UI today — scroll the timeline or filter by status.
## Workspace-wide scan
For a cross-employee view, use **Mission Control / Day Planner** recent-activity lanes and open employees from there. Per-employee history always lives in that employee’s drawer.
Export to CSV or PDF is not available in the Cowork UI. Use the Tess API if you need bulk analysis outside the product.
## Tips
* Review **Failed** runs regularly — repeated failures often share one root cause (connectors, instructions, or approvals)
* Compare **Wake reason** to distinguish scheduled work from manual invokes
* Watch **Credits used** on expensive runs when tuning model or Work Cycle settings
## Next steps
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Advanced Monitoring](/en/cowork/digital-employees/monitoramento-avancado/advanced-monitoring)
* [Work Cycle](/en/cowork/digital-employees/configuracao-de-cron/cron-heartbeat)
# Mission Control monitoring
Source: https://docs.tess.im/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard
Use the Day Planner, employee drawer, and Mesh Canvas to see what needs attention — all inside Cowork Mission Control
## Overview
Monitoring in Cowork happens on the **Mesh Canvas** (Mission Control at `/cowork`) — not on a separate Control Center page. You watch employees from three surfaces that work together:
1. **Day Planner** — upcoming wake-ups and pending items across your workspace
2. **Employee detail drawer** — status, stats, and timeline for one employee
3. **Mesh nodes** — live status badges on each employee on the canvas
## Day Planner
Open the **Mission Control / Day Planner** panel on the Mesh Canvas. It answers “what needs attention now?”
Typical lanes include:
* **Upcoming wake-ups** — scheduled Work Cycle runs about to start
* **Pending approvals** — plan reviews, input requests, connector decisions, and hire reviews waiting on you
* **Recent activity** — quick scan of what ran recently across visible employees
Click an item to jump to the employee on the Mesh and open its drawer.
Resolve pending approvals promptly — blocked runs and scheduled wake-ups stay waiting until you decide.
## Employee detail drawer
Click any employee node to open the drawer. Monitoring details live here:
* **Status badge** — Idle, Active, Running, Paused, Error, Pending approval, or Terminated
* **Summary stats** — run counts, success rate, average duration, and credit usage for this employee
* **Timeline** — recent runs with outcome, duration, and cost per run
* **Quick actions** — invoke, pause, resume, or terminate (when you have permission)
See [Execution History](/en/cowork/digital-employees/historico-execucoes/execution-history) for how to read the timeline and open a run’s full detail.
## Pending items on the Mesh
Employees waiting on you show a **Pending approval** (or similar) status on their node. You may also see cues in the Day Planner. Open the drawer or the live run view to approve, reject, or answer input — see [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions).
## What to watch
| Signal | Where to look | What it means |
| ------------------------ | ------------------------------ | ------------------------------------------------------------- |
| **Error** status | Node badge or drawer | The last run failed — open the timeline and latest run detail |
| **Pending approval** | Day Planner, node, drawer | A human decision is blocking progress |
| **Running** | Node badge | The employee is executing now |
| **Paused** | Node badge or drawer | Scheduled wake-ups are suspended until you resume |
| **Failed runs (recent)** | Day Planner or drawer timeline | Pattern of failures worth investigating |
Cowork does not show per-employee CPU or memory usage. Use run logs, timeline outcomes, and credit usage to judge health.
## Tips
* Start each session in Mission Control — scan Day Planner, then spot-check nodes with Error or Pending approval
* Use **Cowork Layers** to widen or narrow whose employees you see (My area through Full org)
* For deeper per-run insight (planner notes, token/credit breakdown), open a run from the drawer — see [Advanced Monitoring](/en/cowork/digital-employees/monitoramento-avancado/advanced-monitoring)
## Next steps
* [Active employees on the Mesh](/en/cowork/digital-employees/visualizacao-ativos/active-agents-view)
* [Execution History](/en/cowork/digital-employees/historico-execucoes/execution-history)
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
# Advanced Monitoring
Source: https://docs.tess.im/en/cowork/digital-employees/monitoramento-avancado/advanced-monitoring
Deeper insight from the employee drawer and run detail — planner notes, performance summary, and per-run cost
## Overview
Beyond status badges and the Day Planner, Cowork exposes richer monitoring **inside the employee drawer and run detail** — not on a separate analytics dashboard.
Use these views when you need to understand *how* an employee has been working, *how reliably*, and *at what cost*.
## Performance summary (drawer)
The employee drawer includes an aggregate summary for that employee:
* Total runs and split between succeeded and failed
* Success rate over all recorded runs
* Average run duration
* Total credits consumed
These numbers update as new runs complete. Use them to spot drift — rising failures, slower runs, or climbing credit use — before opening individual run details.
## Planner notes (run detail)
Some employees maintain a **planner journal**: compact summaries of recent heartbeats that help the employee stay oriented across runs without keeping an enormous chat context.
When enabled for your workspace, journal entries appear in **run detail** for eligible runs — a readable digest of what the employee planned and did, plus any open threads it flagged for itself.
Planner journal is a workspace capability that may be off by default. If you do not see it, your admin has not enabled it yet.
## Per-run cost and usage
Each run detail shows credits used and, when available, token counts and the model that handled the work. Compare runs to tune:
* Work instructions (shorter, clearer tasks often cost less)
* Model choice in Advanced settings
* Work Cycle frequency (fewer wakes → lower steady spend)
Credit limits configured on the employee (daily/monthly caps) are described in [Detailed Configuration](/en/cowork/digital-employees/configuracao-detalhada/detailed-configuration).
## Goal progress signals
When goal tracking is active, the drawer may surface how the employee reports progress against its stated goal. Treat large gaps between expected and reported progress as a review trigger — adjust instructions or Work Mode rather than assuming silent success.
## When to go deeper vs stay in Mission Control
| Question | Where to look |
| ------------------------------------------- | --------------------------------------- |
| What needs action right now? | Day Planner + node badges |
| Is this employee healthy overall? | Drawer performance summary |
| Why did one run fail or cost too much? | Timeline → run detail |
| What did it plan across several heartbeats? | Run detail planner notes (when enabled) |
## Related
Day Planner, drawer stats, and pending items
Timeline and run detail
# Active employees on the Mesh
Source: https://docs.tess.im/en/cowork/digital-employees/visualizacao-ativos/active-agents-view
See which Digital Employees are running, paused, or need attention — on canvas nodes and in the detail drawer
## Overview
There is no separate “Active Agents” screen. You see who is active, running, paused, in error, or waiting on approval directly on the **Mesh Canvas** and in each employee’s **detail drawer**.
## Status on canvas nodes
Every Digital Employee appears as a node with a **status badge**:
| Status | What you see |
| -------------------- | --------------------------------------------------------- |
| **Idle / Active** | Ready — waiting for the next Work Cycle or manual invoke |
| **Running** | Executing a run now |
| **Paused** | Will not wake on schedule until resumed |
| **Error** | Last run failed — needs review |
| **Pending approval** | Blocked on plan, input, connector, or hire review |
| **Terminated** | Decommissioned (hidden from normal views when applicable) |
Running employees are visually distinct from idle or paused ones. Scan the Mesh for badges that need action.
## Status in the detail drawer
Click a node to open the drawer. The header repeats the current status and adds context:
* Last run outcome (success, failed, or waiting)
* Next scheduled wake-up (when a Work Cycle is configured)
* Quick actions: **Invoke**, **Pause**, **Resume**, or **Terminate** (based on your permissions)
While a run is in progress, open the drawer to follow the live run view and any approval cards.
## Find employees quickly
* **Search employees** — top bar; matching nodes stay highlighted, others dim
* **Cowork Layers** — My area / Direct reports / Their employees / Full org (see [Navigation & Interaction](/en/cowork/mesh-canvas/navigation-interaction))
* **Day Planner** — workspace-wide pending and upcoming items (see [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard))
## Interact with a running employee
* **Pause** — stops future scheduled wake-ups; does not forcibly stop a run already in flight
* **Open run detail** — from the drawer timeline, inspect logs and outcome for the current or latest run
* **Approve or answer** — when status is Pending approval, resolve the card in the drawer or live run view
Runs stuck in Running for an unusually long time may be excluded from “running now” counts in summary views. Open the run detail to see whether it needs recovery or failed silently.
## Tips
* Treat **Error** and **Pending approval** as priority — they block reliable autonomous work
* Use Layers to monitor direct reports’ employees without cluttering your own area
* After fixing a recurring failure, check [Execution History](/en/cowork/digital-employees/historico-execucoes/execution-history) for the pattern
## Next steps
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
* [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions)
# Mesh Canvas Overview
Source: https://docs.tess.im/en/cowork/mesh-canvas/mesh-canvas-overview
Mission Control on the Mesh — employees, squads, documents, teammates, and live status at /cowork
## Overview
The **Mesh Canvas** is Cowork’s main screen — Tess labels it **Cowork / Mission Control**. Digital Employees, squads, documents, and teammates appear as interactive nodes on a shared canvas at `/cowork`.
## What you see
### Node types
* **Employee nodes** — hired Digital Employees with avatar and **status badge** (Running, Paused, Error, etc.)
* **Squad nodes** — groups of employees working on a shared initiative
* **Document nodes** — files and outputs linked to employees; open to review or download
* **Teammate presence** — colleagues currently on Cowork
### Mission Control chrome
* **Header** — Cowork / Mission Control label, credits cues, presence
* **Search employees** — find and highlight nodes by name
* **Cowork Layers** — My area / Direct reports / Their employees / Full org
* **Hire** — dropdown: Open position, Talent Pool, Assemble Team, and related options
* **Day Planner** — upcoming wake-ups and pending approvals (see [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard))
* **Omnibar** — bottom input for tasks and `/hire` (see [Omnibar](/en/cowork/mesh-canvas/omnibar))
## Employee status on nodes
Each employee node reflects live status. Click a node to open the **detail drawer** with stats, timeline, and actions (invoke, pause, resume, terminate). Full state reference: [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle).
## Visibility layers
Who appears on your canvas depends on **Cowork Layers** and your workspace permissions — not decorative filters. Your own employees always show; teammates’ employees appear only when your role allows. Details: [Navigation & Interaction](/en/cowork/mesh-canvas/navigation-interaction).
## Tips
* Use **Search** to focus one employee in a busy org view
* Resolve **Pending approval** nodes from the drawer or Day Planner promptly
* Prefer **Hire → Open position** for full form control; use **`/hire`** in the Omnibar for fast natural-language hiring
## Next steps
* [Main Interface](/en/cowork/primeiros-passos/interface-principal)
* [Navigation & Interaction](/en/cowork/mesh-canvas/navigation-interaction)
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
# Mesh Canvas Navigation & Interaction
Source: https://docs.tess.im/en/cowork/mesh-canvas/navigation-interaction
Zoom, pan, search, Cowork Layers, and the employee detail drawer on Mission Control
## Overview
The Mesh Canvas is an interactive map of your Cowork workspace. Navigation is intentionally simple: pan and zoom the canvas, search by name, choose visibility layers, and click nodes to open the employee drawer.
## Zoom and pan
| Gesture | Behavior |
| ----------------------------- | --------------------------- |
| Mouse wheel / trackpad scroll | Pans the canvas |
| Click-drag on empty space | Pans the canvas |
| Pinch (trackpad / touch) | Zooms in or out |
| `+` / `−` (bottom-right) | Zoom in or out, fit-to-view |
Zoom is bounded to a practical range. **Double-click** on empty canvas does not zoom (it may open Create / Open position when available).
Bottom-right controls also include **background options** and **distraction-free mode** — press `Esc` to exit distraction-free mode.
## Keyboard shortcuts
| Key | Action |
| ---------------------- | --------------------------------------------------------------------------- |
| `Esc` | Exit distraction-free mode, close the Layers menu, or clear multi-selection |
| `Cmd/Ctrl + Z` | Undo the last mesh action |
| `Cmd/Ctrl + Shift + Z` | Redo |
There is no arrow-key pan or keyboard zoom. Use the search field to find employees by name instead of a find shortcut.
## Search employees
1. Click **Search employees** in the top bar
2. Type part of an employee name
3. Matching nodes stay highlighted; others dim
4. The view can auto-focus on the match
## Cowork Layers
The **Layers** menu controls *who* is visible on your canvas:
| Layer | Meaning |
| ------------------- | ------------------------------------------------ |
| **My area** | Your own Digital Employees — always on |
| **Direct reports** | Employees belonging to people who report to you |
| **Their employees** | Digital Employees owned by your direct reports |
| **Full org** | Everyone in the workspace you are allowed to see |
Layers require the matching visibility permission. If a layer is disabled, ask your workspace admin.
## Employee detail drawer
Click any employee node to open the drawer on the side:
* Name, avatar, and **status badge**
* Performance summary and **timeline** of recent runs
* Goal and Work Cycle summary when configured
* **Actions** — Invoke, Pause, Resume, Terminate (fire), and Edit when permitted
* Files and outputs linked to the employee
Pending approvals and input requests appear here and on the live run view — see [Approvals & Interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions).
## Hire entry points
Besides the **Hire** dropdown (Open position, Talent Pool, etc.), you can double-click empty canvas to start creation when the product offers it, or use **`/hire`** in the [Omnibar](/en/cowork/mesh-canvas/omnibar).
## Next steps
* [Mesh Canvas Overview](/en/cowork/mesh-canvas/mesh-canvas-overview)
* [Omnibar](/en/cowork/mesh-canvas/omnibar)
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
# Omnibar
Source: https://docs.tess.im/en/cowork/mesh-canvas/omnibar
Bottom input on Mission Control — route tasks and use /hire to create Digital Employees
## Overview
The **Omnibar** is the text field at the bottom of the Mesh Canvas. Use it to:
1. **Route a task** — type work in plain language and submit to the right employee or flow
2. **Hire with `/hire`** — describe a new role; Tess configures a Digital Employee for you
The Omnibar is not a global command palette — there is no Cmd+K shortcut, and you cannot pause or stop employees from here. Click the field to focus it.
## Route a task
Type what you need done — for example, “Summarize yesterday’s support tickets for the weekly standup” — and submit. Cowork routes the request based on context (selected employee, squad, or workspace rules).
For predictable routing, select the target employee on the Mesh first, then type in the Omnibar.
## `/hire` slash command
### Start the command
1. Click the Omnibar
2. Type `/`
3. Choose **`/hire`** from the floating menu (visible when you can create employees)
4. Add a plain-language description — e.g. `/hire someone to monitor competitor pricing weekly`
5. Submit
### What happens next
Cowork runs a short recruiting sequence, then places the new employee on the Mesh. The first run often starts immediately; in Supervised mode you may need to approve the initial plan in the drawer.
Full walkthrough: [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee).
## Hire dropdown (alternative)
For full control over identity, Work Mode, Work Cycle, and Advanced settings, use **Hire → Open position** instead of `/hire`. Other menu options include **Talent Pool** (ready digital employees with app connections preconfigured) and **Assemble Team** when available in your workspace.
> **Screenshot placeholder — Talent Pool:** Capture **Hire → Talent Pool** showing a ready digital employee card with connectors already configured.
## Permissions
`/hire` and **Hire** require permission to create and invoke Digital Employees in the workspace. If options are missing, ask your workspace admin.
## Next steps
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
* [Mesh Canvas Overview](/en/cowork/mesh-canvas/mesh-canvas-overview)
* [Agent Lifecycle](/en/cowork/digital-employees/ciclo-de-vida/agent-lifecycle)
# Accessing Cowork
Source: https://docs.tess.im/en/cowork/primeiros-passos/accessing-cowork
Open Cowork from the Tess sidebar and land on the Mesh Canvas
## Overview
Cowork is Tess’s real-time space for hiring and managing Digital Employees with your team. This guide shows how to open it and what you see first.
## Prerequisites
* An active Tess account
* Cowork enabled for your workspace (gated feature — ask a workspace admin if you do not see it)
* Permission to use Cowork in that workspace
## How to open Cowork
### Step 1: Find Cowork in the sidebar
In the Tess sidebar (next to **New Chat** and other main items), click **Cowork**.
### Step 2: Land on the Mesh Canvas
You go straight to the **Mesh Canvas** (Mission Control): employee nodes, presence, search, Hire, Layers, and the Omnibar at the bottom.
## If you do not see Cowork
1. Ask your workspace admin to enable Cowork for the workspace
2. Confirm your role can use Digital Employees
3. Contact your admin if the menu item is still missing
## Next steps
* [Main Interface (Mesh Canvas)](/en/cowork/primeiros-passos/interface-principal)
* [Mesh Canvas overview](/en/cowork/mesh-canvas/mesh-canvas-overview)
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
# Main Interface (Mesh Canvas)
Source: https://docs.tess.im/en/cowork/primeiros-passos/interface-principal
Mission Control chrome: canvas, Hire, Layers, search, Omnibar, and employee drawer
## Overview
The **Mesh Canvas** is Cowork’s main screen. Tess labels it as **Cowork / Mission Control**. Digital Employees, squads, documents, and teammates appear as nodes on an interactive canvas.
## Layout
### Header
Shows **Cowork / Mission Control**, wallet/credits cues when relevant, and teammate presence controls.
### Action bar
* **Search employees** — find agents by name; matches stay highlighted
* **Cowork Layers** — whose employees you see (My area / Direct reports / Their employees / Full org), based on visibility permissions
* **Hire** — dropdown: Open position (full form), Talent Pool, Assemble Team, and related options
### Center canvas
* **Employee nodes** — avatar and status; click to open the **detail drawer**
* **Squad nodes** — a team of employees
* **Document nodes** — files/outputs; open to review workspace files
* **Teammate presence** — who else is on Cowork
**Interactions**
* **Zoom** — mouse wheel / trackpad, or `+` / `−` controls
* **Pan** — drag empty canvas space
* **Click a node** — open the employee (or document) drawer
* **Double-click empty canvas** — can open Create / Open position (when available)
### Mission Control — Day Planner
Collapsible panel for upcoming wake-ups, pending hire/review items, and operational lanes. Use it for “what needs attention now,” not as a separate Control Center app.
### Bottom Omnibar
Type a task to route work, or use `/hire` followed by a natural-language role description. See [Omnibar](/en/cowork/mesh-canvas/omnibar).
### Bottom-right controls
Zoom in/out, fit-to-view, background options, and distraction-free mode (`Esc` to exit).
## Empty vs active canvas
* **Empty** — no employees yet; Omnibar and **Hire** are ready for the first hire
* **Active** — employee nodes with live status, optional squads and documents, teammate presence
## Next steps
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
* [Mesh Canvas Navigation](/en/cowork/mesh-canvas/navigation-interaction)
* [Real-time Collaboration](/en/cowork/colaboracao-tempo-real/realtime-collaboration)
# Project Rooms (concept)
Source: https://docs.tess.im/en/cowork/project-rooms/project-rooms
Squads are what you use in Cowork — Project Room is the shared container behind a Squad
## Use Squads in Cowork
In Cowork you organize multi-employee work with **Squads** — nodes on the **Mesh Canvas** with a **Squad panel** for members, runs, and shared files. That is the product surface you use day to day.
Cowork does **not** expose a separate Project Rooms management screen.
## What “Project Room” means
**Project Room** is an under-the-hood name for the shared container behind a Squad:
* **Membership** — which Digital Employees (and you) belong to the initiative
* **Shared files** — including the squad’s working document
* **Scope** — squad documents are visible to squad members on the mesh and in drawers
When you **create a Squad**, Tess provisions that shared container automatically. You do not create or browse Project Rooms yourself.
## Where to go next
* [Squads fundamentals](/en/cowork/squads/squads-fundamentals) — members, modes, and the working document
* [Create a Squad](/en/cowork/squads/squad-creation)
* [Squad runs](/en/cowork/squads/squad-runs)
## Other languages
* [Português (BR)](/pt/cowork/project-rooms/salas-projeto)
* [Español](/es/cowork/project-rooms/salas-proyecto)
# Create & Manage a Squad
Source: https://docs.tess.im/en/cowork/squads/squad-creation
Create a Squad from Cowork, add members, and update settings from the Squad panel
## Overview
Create and manage Squads from the **Mesh Canvas** — use **Create Squad** (or the squad creation flow from **Hire → Assemble Team** when available). Cowork does not expose a separate Project Rooms product screen.
## Create a Squad
1. On the Mesh Canvas, open **Create Squad** (or **Hire → Assemble Team**).
2. Fill in:
* **Name** (required)
* **Color** (optional — helps spot the squad on the canvas)
* **Goal** (optional — short description of what the squad should achieve)
* **Execution mode** — how members coordinate (see [Squads fundamentals](/en/cowork/squads/squads-fundamentals))
* **Output format** — working document update, new document, or review only
3. **Add members** — pick at least one Digital Employee, up to **8**. Optionally mark one as **lead** and set member order for handoff modes.
4. **Save** — the squad appears as a node on the mesh with a shared working document.
An employee can only be in **one** active squad. Adding them to a new squad removes them from any other squad first.
## Squad panel
Click a **squad node** on the mesh to open the **Squad panel**. From there you can:
* View members and the lead
* Open the **shared working document**
* Start or monitor a squad run
* Edit name, goal, color, execution mode, and output format
* Add or remove members (still capped at 8)
* Archive the squad when the initiative is done
## Tips
* Use descriptive names (e.g. “Q4 Market Research”) so squads stay recognizable on a busy canvas
* Keep squads small — coordination cost grows quickly beyond a handful of members
* Plan membership knowing each employee can only belong to one squad at a time
## Next steps
* [Squads fundamentals](/en/cowork/squads/squads-fundamentals)
* [Squad runs](/en/cowork/squads/squad-runs)
## Other languages
* [Português (BR)](/pt/cowork/squads/criacao-squad)
* [Español](/es/cowork/squads/creacion-squad)
# Squad Runs
Source: https://docs.tess.im/en/cowork/squads/squad-runs
Run a Squad from the Mesh Canvas and follow progress through members and shared documents
## Overview
A **squad run** executes the squad’s members according to its **execution mode**. Results land in the shared **working document** or as a **new document node** on the mesh, depending on the squad’s output format.
## Start a run
1. Click the **squad node** on the Mesh Canvas.
2. In the **Squad panel**, start a run (or trigger from the squad’s run control when shown).
3. Members execute according to the mode you configured — parallel, handoff, review, and so on.
See [Squads fundamentals](/en/cowork/squads/squads-fundamentals) for what each mode does.
## Monitor progress
* **Squad node** — shows the squad is active; open the panel for a high-level view
* **Member nodes** — each member’s status badge reflects its own run (Idle, Running, Pending approval, etc.)
* **Member drawer** — click a member to see timeline, approvals, and files for that run
* **Mission Control / Day Planner** — pending approvals and wake-ups across visible employees
Individual member runs behave like any Digital Employee run. If a member stops for **plan approval** or **input needed**, resolve it from that member’s drawer — the same as a solo employee.
## Review results
After the run:
1. Open the squad’s **working document** node on the mesh (or from the Squad panel)
2. Check each **member drawer** timeline for logs and credit use
3. Look for any **new document nodes** if the output format was “new document”
Use **linear handoff** for pipelines, **review board** or **debate** for quality checks, and **parallel** when members can work independently on shared context.
## Next steps
* [Squads fundamentals](/en/cowork/squads/squads-fundamentals)
* [Create a Squad](/en/cowork/squads/squad-creation)
* [Documents on the mesh](/en/cowork/artifacts/artifacts-overview)
## Other languages
* [Português (BR)](/pt/cowork/squads/squad-runs)
* [Español](/es/cowork/squads/squad-runs)
# Squads Fundamentals
Source: https://docs.tess.im/en/cowork/squads/squads-fundamentals
What a Squad is, how members coordinate, and when to use one on the Mesh Canvas
## Overview
A **Squad** is how you group Digital Employees around one initiative on the **Mesh Canvas**. Squads appear as their own nodes — open one to see members, shared files, and run controls in the **Squad panel**.
In Cowork you always work with **Squads**, not a separate “Project Rooms” screen. Behind the scenes, each Squad uses a shared container for membership and files; you do not manage that container directly.
## What a Squad includes
* **Name and color** — identify the squad on the canvas
* **Up to 8 members** — Digital Employees only; each employee can belong to one active squad at a time
* **Optional lead** — one member you mark as lead when someone should own the final output
* **Shared working document** — created automatically; the squad’s living deliverable
* **Execution mode** — how members coordinate when the squad runs (see below)
## Execution modes
| Mode | Best for |
| ------------------ | ---------------------------------------------------- |
| **Individual** | Members work independently on their own slice |
| **Parallel** | Members work at the same time against shared context |
| **Linear handoff** | Pipeline: each member builds on the previous one |
| **Review board** | Members critique a shared draft |
| **Debate** | Members argue positions, then converge |
| **Standup** | Status-style updates across members |
| **Brainstorm** | Open ideation round |
| **War room** | Focused, high-intensity problem solving |
**Output format** tells the squad where results go:
* Update the **shared working document**
* Create a **new document** on the mesh
* **Review only** — feedback without changing the working document
There is no fixed “Orchestrator / Specialist / Validator” role set. Every member participates the same way unless you designate a **lead**.
## Common use cases
* **Research + synthesis** — several employees gather input; the lead (or last handoff) produces the report in the working document
* **Review board** — a draft passes through multiple reviewers
* **Recurring rituals** — standup or war-room modes on a schedule via [Squad runs](/en/cowork/squads/squad-runs)
## Tips
* Start with **2–3 members** before scaling toward the 8-member cap
* Use a **lead** when one employee should own the final deliverable
* Keep the **working document** as the single source of truth for the squad’s output
## Next steps
* [Create a Squad](/en/cowork/squads/squad-creation)
* [Squad runs](/en/cowork/squads/squad-runs)
* [Documents on the mesh](/en/cowork/artifacts/artifacts-overview)
## Other languages
* [Português (BR)](/pt/cowork/squads/squads-fundamentais)
* [Español](/es/cowork/squads/squads-fundamentales)
# Run Stats & Operational View
Source: https://docs.tess.im/en/cowork/voice-analytics/task-board-analytics
Per-employee run analytics in the drawer and workspace cues in Mission Control
## Overview
Operational visibility in Cowork lives on the **Mesh Canvas (Mission Control)** — not on a separate Control Center page. You read run stats from the **employee drawer** and scan what needs attention in **Mission Control / Day Planner**.
This article covers what you actually see for **run analytics**. It does not describe a standalone task-board product screen.
## Mission Control — Day Planner
Open the **Day Planner** panel on the Mesh Canvas for a workspace-level operational view:
* **Upcoming wake-ups** — scheduled Work Cycle runs about to start
* **Pending approvals** — plan reviews, input requests, connector decisions, hire reviews
* **Recent activity** — quick scan of what ran across employees you can see
Click an item to focus the employee on the mesh and open its drawer.
Clear pending approvals promptly — blocked runs stay waiting until you decide.
## Employee drawer — summary stats
Click any **employee node** to open the drawer. At the top you typically see aggregate stats for that employee:
| Stat | Meaning |
| ------------- | ---------------------------------------------------------------- |
| **Runs** | Total recorded executions (heartbeats, manual runs, voice, etc.) |
| **Success %** | Share of runs that completed successfully |
| **Credits** | Total credits consumed across runs |
These numbers come from the employee’s run history and refresh when you open or reload the drawer.
## Execution timeline
Below the summary, the **timeline** lists individual runs. Each entry shows:
* **Status** — Running, Success, Failed, Pending approval, and similar labels
* **Wake reason** — scheduled heartbeat, manual trigger, voice call, etc.
* **Duration** — seconds for completed runs
* **Cost** — credits for that run when available
Open a run row for full detail — planner notes, tool steps, and documents produced.
Voice calls appear as **Voice call** rows with transcript and duration, separate from regular heartbeat runs.
## Mesh node badges
Without opening the drawer, **status badges** on employee nodes give a quick read: Idle, Running, Paused, Error, Pending approval. Use badges for scanning; use the drawer for numbers and history.
## What this is not
* Manual Kanban-style workspace task boards are outside the mesh/drawer surfaces described here
* For deeper per-run cost and planner detail, open a run from the timeline — see [Advanced monitoring](/en/cowork/digital-employees/monitoramento-avancado/advanced-monitoring)
## Next steps
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
* [Execution history](/en/cowork/digital-employees/historico-execucoes/execution-history)
* [Voice calls](/en/cowork/voice-analytics/voice-calls)
## Other languages
* [Português (BR)](/pt/cowork/voice-analytics/quadro-tarefas-analytics)
* [Español](/es/cowork/voice-analytics/tablero-tareas-analytics)
# Voice Calls
Source: https://docs.tess.im/en/cowork/voice-analytics/voice-calls
Start a live voice conversation with a Digital Employee from the drawer when voice is enabled
## Overview
When your workspace has **voice** enabled, you can talk to a Digital Employee in real time from Cowork. You speak naturally; the employee responds with voice and can use connectors, search, and screen share when you allow it.
Voice is **not** a separate app — you start it from the **employee drawer** on the Mesh Canvas.
## Start a call
1. Open **Cowork** and click a Digital Employee on the mesh.
2. In the **employee drawer**, click the **phone** button in the header (**Call**).
3. A **Calling…** overlay appears while the session connects. Cancel before connect if you opened it by mistake.
4. When connected, a **voice panel** opens (top-right) with the employee’s avatar and live status.
If the phone button is disabled, voice may be off for your workspace or your role may not allow calls. You can still monitor the employee from the drawer and Mission Control.
## During the call
The panel shows a pulsing avatar and a status label:
| Status | Meaning |
| -------------- | ------------------------------------------- |
| **Listening…** | The platform heard you speak |
| **Speaking…** | The employee is responding with voice |
| **Thinking…** | A tool is running (search, connector, etc.) |
| Idle | Waiting for the next turn |
### Controls
| Control | What it does |
| ---------------- | ----------------------------------------------- |
| **Microphone** | Mute or unmute |
| **Screen share** | Let the employee analyze what is on your screen |
| **Minify** | Collapse to a small floating orb |
| **Pop out** | Open in a separate window (supported browsers) |
| **Hang up** | End the call |
### What the employee can do
During a call the employee may search past runs, use the web, stage connector actions, and analyze your screen when shared. Actions that change external systems follow **prepare → confirm → execute** — the employee asks before running them.
## After the call
A **Voice call** entry appears in the employee’s **timeline** in the drawer. Open it to read the transcript and see duration. Voice usage consumes workspace **credits** like other AI consumption (based on tokens processed during the call).
## Next steps
* [Run analytics in the drawer](/en/cowork/voice-analytics/task-board-analytics)
* [Approvals & interactions](/en/cowork/digital-employees/aprovacoes-e-interacoes/approvals-interactions)
* [Mission Control monitoring](/en/cowork/digital-employees/monitor-dashboard/monitor-dashboard)
## Other languages
* [Português (BR)](/pt/cowork/voice-analytics/chamadas-voz)
* [Español](/es/cowork/voice-analytics/llamadas-voz)
# What is Cowork
Source: https://docs.tess.im/en/cowork/what-is-cowork
Learn the fundamentals of Cowork — the Mesh Canvas where Digital Employees work with your team 24/7
# What is Cowork
Cowork is **Tess's** visual collaboration space where you hire, monitor, and guide autonomous **Digital Employees** on business work. You operate from the **Mesh Canvas** (Mission Control): agents, teammates, documents, and squads appear as live nodes you can interact with.
## Why Cowork?
Traditional automation handles one-off tasks. Cowork supports ongoing team-level work:
* **Digital Employees** run on a schedule (Work Cycle) or when you trigger them
* **Live collaboration** with teammate presence on the same canvas
* **Documents on the canvas** capture outputs you can open and share
* **Squads** group employees that work together
* **Human oversight** via plan approvals, input requests, and connector action reviews
## The Mesh Canvas
Open **Cowork** in the Tess sidebar. You land on the Mesh Canvas — your Mission Control view.
### What you see
* **Employee nodes** — hired Digital Employees with avatar and status; click to open the detail drawer
* **Teammate presence** — colleagues currently on Cowork
* **Document nodes** — files and outputs linked to employees
* **Squad nodes** — teams of employees working together
* **Omnibar** — bottom input for tasks or `/hire`
* **Hire** — dropdown to create employees (Open position, Talent Pool, and related options)
* **Mission Control / Day Planner** — upcoming wake-ups and pending items
## Core concepts
### Digital Employees
Agents you hire once and run repeatedly. In the Hire / Edit Employee form you set:
* **Identity** — name, avatar, voice, optional Goal
* **Work instructions** — how the employee should operate
* **Work Mode** — Supervised vs Autonomous
* **Work Cycle** — when the employee wakes (Time / Day / Week / Month / Interval / None)
* **Advanced settings** — personality, timezone, knowledge base, model, tools, Credits/day and Credits/month
You can also create an employee with `/hire` in the Omnibar (natural language; no field-by-field form).
### Documents & outputs
When employees produce files, they show up as document nodes on the canvas and in the employee drawer. Open a node to review or download workspace files.
### Squads
A **Squad** is how you assemble several Digital Employees (and shared files) around one initiative. Create and manage squads from Cowork — not from a separate “Project Rooms” product screen.
### Approvals & input
During a run, the employee may pause for **plan approval**, **input needed**, or **connector action** review. Those requests appear on the employee drawer and on the live run view — there is no separate approvals inbox.
## Getting started
In the Tess sidebar, click **Cowork**. You land on the Mesh Canvas (Mission Control).
Use **Hire → Open position** for the full form, or type `/hire …` in the Omnibar for a fast natural-language hire.
The employee appears on the mesh. Open its drawer to see status, schedule, and timeline. Approve the first plan if prompted.
Open document nodes or the drawer’s files section to collect results.
Create a Squad when several employees should share context and work together.
## Features at a glance
| Feature | What it does | When to use |
| --------------------- | ---------------------------------------------------- | --------------------------- |
| **Digital Employees** | Hire agents that run on a Work Cycle or on demand | Recurring or delegated work |
| **Mesh Canvas** | Mission Control view of people, agents, docs, squads | Day-to-day monitoring |
| **Documents** | Outputs visible on the canvas and in the drawer | Reviewing deliverables |
| **Squads** | Coordinate multiple employees | Multi-agent initiatives |
| **Approvals** | Plan / input / connector gates in the drawer | Supervised work |
| **Voice** | Call an employee from the drawer (when enabled) | Live guidance during a run |
## What's next?
* [Accessing Cowork](/en/cowork/primeiros-passos/accessing-cowork)
* [Main Interface (Mesh Canvas)](/en/cowork/primeiros-passos/interface-principal)
* [Creating a Digital Employee](/en/cowork/digital-employees/configuracao-basica/criando-um-digital-employee)
Clear goals and work instructions up front reduce how often the employee needs to stop for approval or input.
# Deep Analysis
Source: https://docs.tess.im/en/deep-analysis
LLMs are excellent at interpreting text, writing, summarizing, and generating content. But when it comes to calculations, statistics, and data analysis, any model will have an uncomfortable margin of error — which, for sensitive professional tasks, is unacceptable. For financial reports, sales spreadsheets, and business decisions, you need absolute precision.
That is exactly what Deep Analysis is for: a tool that combines LLM natural language conversation with the accuracy of traditional computing.
### **What is Deep Analysis?**
Deep Analysis is a secure and isolated environment (a "sandbox") where, instead of the AI trying to do the math "in its head", it:
1. understands what you want to do with the data
2. writes Python code to execute that task
3. runs that code in the sandbox
4. returns the result with 100% mathematically correct calculations
In other words: you talk in natural language; Tess creates a virtual machine, translates it into code, executes it, and delivers the ready result (tables, metrics, charts, segmentations, etc.).
### **How to use Deep Analysis in the chat**
Whenever you need any quantitative or qualitative/quantitative analysis, a report, HTML, or similar processing, activate the Deep Analysis tool in the chat!
If you have a base document, remember to send your file, make your request in natural language, and mention the file and what needs to be done with it.
You can also use Deep Analysis to work on interactive reports or dashboards in HTML format:
**Access the HTML Report** ([link](https://tess-workflows-files.storage.googleapis.com/6ca511cbbab87f2226b638f5d69a04e7316b6e8d/auditoria_despesas_q3_completa.html))
The same applies to Dashboards:
**Access the HTML Dashboard** ([link](https://tess-workflows-files.storage.googleapis.com/a3edcb57bbe013d17e362703fa6b65b70c3cdfca/dashboard_auditoria_despesas_q3_interativo.html))
For Dashboards, since the view is built with static data, there is no automatic HTML update — therefore, any change requires the HTML to be regenerated.
### Use it whenever data accuracy is the top priority, for example:
Financial, sales, and customer analyses; period comparisons (month over month, year over year), etc.
Calculate EBITDA, profit margin, average ticket; perform statistical analyses (averages, medians, standard deviation, etc.).
Data visualization, bar charts, line charts, pie charts, scatter plots, etc.; visualize sales trends, churn, engagement, costs.
Process experimental data; execute complex formulas; engineering, science, and experiments, etc.
Identify best-selling products; segment customers by value range or purchase frequency, etc.
Evaluate campaign or channel performance; project scenarios and strategies based on historical data, etc.
### **Common supported formats**
* Spreadsheets (XLSX)
* CSV files
* Other structured formats that can be read via Python (when applicable)
Prompt examples: 1. "Analyze this file vendas\_trimestre.xlsx, calculate the total sales for each product category, and create a pie chart showing each one's share." 2. "In this customer CSV, calculate the average ticket by region and display it in a table sorted from highest to lowest." 3. "Generate a line chart showing the monthly revenue trend over the last 12 months."
Beyond that, the more literal and detailed your prompt, the better the AI's understanding and performance in this case. Tools of this type tend to respond well to objective and precise commands.
In this process, Tess will write the code, execute it in the sandbox, and return the results (tables, explanations, and, when requested, charts generated from the data).
Deep Analysis is the bridge between natural language conversation and the rigor of data science. It ensures that reports, analyses, and charts generated by Tess AI are not just intelligent — but mathematically correct.
# Discord
Source: https://docs.tess.im/en/discord
The **Discord** connector integrates Tess with Discord. Once connected, the AI can help read accessible channels, summarize community discussions, and support messaging workflows inside chats and agents.
Discord is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Discord account with access to the servers/channels you need.
* Permission to authorize the Discord app for those servers.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Discord** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Discord** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Find channels and recent messages** the account can access
* **Summarize community discussions** into decisions and action items
* **Support moderation and community ops** with clearer context
* **Help draft or send updates** when write permissions are available
* **Keep community signal close to your Tess workflows**
## Example prompts
> 1. Summarize the last day of discussion in #product-feedback and list top requests.
> 2. What announcements were posted this week in the community server?
> 3. Draft a release update for #announcements and show it before sending.
> 4. Find messages mentioning onboarding friction and group them by theme.
## Best practices
* Mention the server/channel when names collide.
* Ask for a draft before posting to public channels.
* In agents, define whether Discord is for listening, summarization, or posting.
## Troubleshooting
Reconnect with an account that belongs to the target server and has the needed channel permissions.
Reconnect Discord in Connectors after app removal or token revocation.
The connected account may be read-only there. Check Discord roles/permissions.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# DocuSign
Source: https://docs.tess.im/en/docusign
The **DocuSign** connector integrates Tess with DocuSign. Once connected, the AI can help check agreement status and support signature-related routines inside chats and agents.
DocuSign is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A DocuSign account with access to the envelopes/agreements you need.
* Permission to authorize the DocuSign app for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **DocuSign** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **DocuSign** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Check envelope/agreement status** for contracts in progress
* **Find agreements** by recipient, subject, or status when accessible
* **Support signature follow-ups** with clearer next steps
* **Help ops and legal-adjacent routines** stay coordinated in Tess
* **Reduce manual status checks** across inboxes and portals
## Example prompts
> 1. What is the status of the Acme MSA envelope in DocuSign?
> 2. List agreements waiting for signature for more than 3 days.
> 3. Summarize who still needs to sign the onboarding packet for Company Y.
> 4. Draft a polite reminder for the pending signer on the Acme MSA.
## Best practices
* Use unique agreement names or envelope IDs when possible.
* Ask before triggering send/void actions.
* In agents, define whether DocuSign is for status tracking or active envelope actions.
## Troubleshooting
Reconnect with a DocuSign account that can access the needed envelopes and approve the app.
Reconnect DocuSign in Connectors after credential or permission changes.
Confirm the connected account can see that envelope in DocuSign.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Embedding
Source: https://docs.tess.im/en/embedding
**IMPORTANT:**\
Feature available only on PRO, Business, and Enterprise plans.
Make your Tess agent available directly within websites and applications, as a chat widget or embedded component. Ideal for customer support, lead capture, onboarding, and internal assistants.
### **What is it?**
The Embedding feature allows you to embed a Tess agent into:
* institutional websites
* customer logged-in areas
* your own products / SaaS
* intranets and internal portals
Tess generates an embed code (usually a script or iframe) for you to paste into your website/app. From there, your users can chat with the agent directly within that interface.
### Why it matters
The user does not need to leave your website to talk to the agent.
Support, FAQ, and onboarding agents always available.
Sales agents help qualify and guide leads in real time.
The same agent can be used across multiple channels (website, app, internal and external).
### How to generate an embed code?
The first step is creating and testing the agent (prompt, Knowledge Base, Tools, etc.).
Configure the visibility, as your agent cannot be private in order to enable the Embed feature.
In the Agent Studio agent list, click the publication settings to access the agent's detailed settings.
Scroll to the bottom "Configure Embedding" option.
Choose the embed format and use the code in the HTML of your website/app and activate the public access option.
This way, the chat widget or component will start appearing for visitors, connected to your agent.
**Best practices**
* Start by embedding in test/staging environments before going to production.
* Make sure the agent is configured and tested for external use.
* Verify that your company's privacy policies cover interactions with AI agents.
# Gemini 3.7 Flash
Source: https://docs.tess.im/en/gemini-3-7-flash
Gemini 3.7 Flash (Google DeepMind) is the new Flash workhorse in Tess — built for **coding, production agents, and knowledge work**, with intro pricing at **half of Gemini 3.6 Flash** through 31 December 2026.
| **Model ID**
Text + multimodal |
## What changed vs Gemini 3.7 Flash
| | Gemini 3.7 Flash | Gemini 3.8 Flash |
| ----------------------------- | -------------------------------- | --------------------------------------------------- |
| Focus | Coding + agents + knowledge work | Long-horizon coding + autonomous agents |
| Context | 1M / 64K | 1M / 64K |
| DeepSWE (long-horizon coding) | 65.3% | **Outperforms 3.7 and most larger frontier models** |
| HLE-Verified | — | **54.9%** |
| Tess credits / 100 tokens | 0.036 in / 0.180 out | **0.036 in / 0.180 out** (50% off) |
| Modalities | Text, image, audio, video | Text, image, audio, video |
Native **reasoning** (effort **low / medium / high**, default **medium**), **tools** (function calling / MCP, search, computer use), and **vision**. On hard tasks it works harder — extra reasoning steps and iterative tool calls, which can use more tokens at higher effort.
## Pricing (Tess credits)
Values follow [Models and Costs](/en/models-and-cost) (credits per 100 tokens). This is the **50% off** rate through **31 December 2026**:
| Model | Input / 100 tokens | Output / 100 tokens |
| ---------------- | ------------------ | ------------------- |
| Gemini 3.8 Flash | 0.036 | 0.180 |
**50% off through the end of 2026.** Pricing changes from **1 January 2027**.
>
## Ideal use cases in Tess
1. Long-horizon coding agents that have to finish a change end to end
2. Multi-step agent workflows — planning, tool loops, error recovery
3. Quantitative and professional analysis (finance, legal-style research)
4. Hard multi-step reasoning across STEM and knowledge work (HLE-Verified 54.9%)
5. Web development against visual references
6. Multimodal turns (text + image + audio + video)
**Best practices**
* Prefer **3.8 Flash** over 3.7 Flash when coding quality and agent reliability matter more than token count.
* Keep **3.7 Flash** for efficiency-first workloads — Google still supports it, and 3.8 can spend more tokens at higher effort.
* Keep **3.5 Flash-Lite** for high-volume extraction, classification, and summarization.
See also: [Gemini 3.7 Flash](/en/gemini-3-7-flash) · [Gemini Flash](/en/gemini-flash) · [Models and Costs](/en/models-and-cost) · [Gemini 3.8 Flash (Google)](https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/).
# GitHub
Source: https://docs.tess.im/en/github
The **GitHub** connector integrates Tess with GitHub for code collaboration. Once connected, the AI can inspect repositories, summarize pull requests and issues, and support engineering workflows inside chats and agents.
GitHub is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A GitHub account with access to the repositories you want to use.
* Permission to authorize the GitHub OAuth app for those repos/orgs.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **GitHub** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **GitHub** should appear under **Connected**, ready for chats and agents.
## What you can do
* **List and inspect repositories**, branches, and recent activity
* **Review pull requests** — summarize changes, comments, and status
* **Work with issues** — search, create, update, and triage
* **Support release and CI context** when the account can see checks and workflows
* **Help product and engineering teams** keep technical context in one place
## Example prompts
> 1. List the most recent pull requests in the project and summarize the purpose of each one.
> 2. Find issues related to the connectors integration and organize them by priority.
> 3. Summarize what changed in the latest open PRs and call out risks.
> 4. Create an issue titled 'Docs gap on Connectors' with a short description and label it documentation.
## Best practices
* Name the owner/repo when you have access to many repositories.
* Ask for a summary before requesting code-changing actions.
* In agents, clarify whether GitHub is for status, triage, or drafting changes.
## Troubleshooting
Re-authorize with an account that can access the organization/repos, and approve org access if GitHub asks.
Reconnect GitHub in Connectors after password, SSO, or token revocation changes.
Confirm the connected account has permission on that repository.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# GLM 5.2
Source: https://docs.tess.im/en/glm-5-2
The GLM-5.2 is the high-performance *open-source* language model developed by Zhipu AI, designed specifically for *long-horizon tasks*.
With a massive context window of 1 million tokens with no loss of accuracy (*lossless*), it is the ideal choice for reading complete codebases, complex interconnected refactoring, and advanced development of agent-structured engineering *workflows* in Tess.
| **Model ID**
Text-to-Text |
## Capabilities
* Reasoning: Has *Thinking* mode with adjustable capacity and controllable effort for difficult tasks.
* Tools (Function Calling / MCP): Highly reliable and focused on staying within scope.
* Structured Output (JSON): Ideal for seamlessly integrating with the operational flows of external tools.
See more in the official documentation: [glm 5.2 documentation](https://docs.z.ai/guides/llm/glm-5.2).
## Details (context, cost, retention)
Support for 1 million tokens makes it possible to send an entire code repository, extensive manuals, and heavy histories in a single agent *prompt*. It keeps continuous information without getting lost in "hallucinations" as the chat progresses. It supports *Context Caching*, which makes long conversations cheaper on the platform.
To use the maximum context, you need to activate Max Mode in the chat, but this may involve higher costs.
It can outperform several competitors (such as DeepSeek v4 and Gemini 3.1 Pro in sustained coding) while costing around 1/6 of the price of equivalent proprietary alternatives from other providers.
## Pricing and consumption
Credit consumption in Tess for this model occurs according to the tokens processed:
* Input Tokens (Environmental reading / *Prompt*): 0.672 credits / 1K tokens
* Output Tokens (Response generation): 2.112 credits / 1K tokens
*Tasks with 1M tokens can generate a high peak in reading consumption due to the absolute volume of data entered in the input. Using the Context Caching feature can help automatically reduce this cost.*
**Best practices**
* **Set safety limits in coding:** Because it strictly follows production architectural standards, give clear restrictive instructions in the *prompt*, such as: *"Adopt the lint standards, use commit convention X, and test rule Y in isolation"*. GLM-5.2 retains this command much better than conventional models.
* **Increase reasoning in interactions with *Bugs*:** For problems such as server log analysis, instruct it in your *prompt* and in the Agents to use step-by-step reasoning before printing the final solution.
* **Redirect multimodal cases:** Since it does not have image capabilities (*Vision*), if your automation needs to read screens and run tests using screenshots of the visual interface, route this step first to the GLM-5V-Turbo or GLM-OCR models.
The GLM-5.2 model by Zhipu AI breaks the barrier between open source and top-tier enterprise execution. With its ability to absorb large amounts of information combined with logical reasoning focused on staying on track for long tasks, it is the ideal tool inside Tess for engineers, advanced researchers, and automation creators who cannot risk technical failures across large volumes of data transition.
# GLM 5.3
Source: https://docs.tess.im/en/glm-5-3
GLM 5.3 (Zhipu AI / Z.ai) is the **text-only flagship** for **complex software engineering** and **long-horizon agents** in Tess. Same 1M context as GLM 5.2 — stronger reasoning, always on, with native tools.
| **Model ID**
Text-to-text |
## What changed vs GLM 5.2
| | GLM 5.2 | GLM 5.3 |
| ------------------------- | ------------------------------- | -------------------------------------------------- |
| Focus | Long-horizon open-source coding | Software engineering + persistent agents |
| Context | 1M | 1M |
| Reasoning | On/off (Thinking) | **Always on** — low / high / **max** (default max) |
| Vision | No | No |
| Tools | Yes | Yes |
| Tess credits / 100 tokens | 0.067 in / 0.211 out | **0.192 in / 0.603 out** |
Native **reasoning** and **tools** (function calling / MCP). **No vision** — for screenshots, UI, or video, use **GLM 5.3 Flash** (`glm-5.3-flash`) in the same catalog.
## Pricing (Tess credits)
Values follow [Models and Costs](/en/models-and-cost) (credits per 100 tokens):
| Model | Input / 100 tokens | Output / 100 tokens | Cache read / 100 tokens |
| ------- | ------------------ | ------------------- | ----------------------- |
| GLM 5.3 | 0.192 | 0.603 | 0.036 |
GLM 5.3 costs about **3× GLM 5.2**. Cached context reads are billed below a full input pass — keep long threads on the same model to take advantage of that.
> **Screenshot placeholder — model picker:** Capture the chat model selector with **GLM 5.3** selected.
## Ideal use cases in Tess
1. Long-horizon software engineering — multi-file refactors, debugging, implementation on a large codebase
2. Persistent agents — planning, tool loops, and multi-step execution without dropping the thread
3. Deep reasoning by default — tasks that must think before the final answer
4. Text-only workflows when vision is not needed
5. 1M-context sessions without switching models
**Best practices**
* Reasoning **cannot be turned off**. Every turn spends reasoning tokens — even on **low**. Do not use GLM 5.3 as a cheap extractor.
* Start on **high**; reserve **max** for planning-heavy or long tool loops.
* Prefer **GLM 5.2** (`glm-5.2`) when you need the same 1M context at lower cost and can live with lighter reasoning.
* Prefer **GLM 5.3 Flash** when the job includes images or video, or when you want Flash-priced agents with similar agentic quality.
* Lean on context cache in long chats to keep input cost down.
See also: [GLM 5.2](/en/glm-5-2) · [Models and Costs](/en/models-and-cost) · [GLM 5.3 (OpenRouter)](https://openrouter.ai/z-ai/glm-5.3).
# Google Drive
Source: https://docs.tess.im/en/google-drive
Connect Google Drive to Tess to find, organize, and work with files from chat and agents.
The **Google Drive** connector integrates Tess with Google Drive storage. Once connected, the AI can search files and folders, help organize content, and support document workflows inside chats and agents.
Google Drive is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Google account with access to the Drive files/folders you need.
* Permission to authorize Google Drive OAuth scopes for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Google Drive** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Google Drive** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search files and folders** by name, type, or location
* **Summarize and locate documents** relevant to a task
* **Create folders and organize files** when the account has write access
* **Support sharing workflows** within the permissions of the connected account
* **Work across My Drive and accessible shared drives**
## Example prompts
> 1. Find the latest proposal PDF about Acme and summarize the commercial terms.
> 2. List files modified in the last 7 days in the Marketing folder.
> 3. Create a folder named 'Q3 Launch' and tell me where it was created.
> 4. Locate the onboarding checklist and outline the missing steps.
## Best practices
* Prefer folder or file names that are unique enough to avoid ambiguity.
* Ask before destructive actions like permanent deletes.
* In agents, define whether Drive is for search-only or also file organization.
## Troubleshooting
Reconnect Drive and confirm the Google account can grant the requested access. Workspace policies may block the app.
Reconnect Google Drive in Connectors after credential or admin policy changes.
Confirm the connected account can access that item (including shared drives).
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Google Meet
Source: https://docs.tess.im/en/google-meet
The **Google Meet** connector integrates Tess with Google Meet. Once connected, the AI can help create meeting spaces and work with conference-related information inside chats and agents.
Google Meet is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Google account with access to Google Meet.
* Permission to authorize Meet-related OAuth scopes for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Google Meet** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Google Meet** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Create Meet spaces** for calls and working sessions
* **Retrieve meeting details** such as join links and space identifiers
* **Support conference follow-up** when records, participants, or recordings are available to the account
* **Combine with Calendar** when you also need to attach meetings to events
* **Reduce tab switching** for scheduling and meeting prep
## Example prompts
> 1. Create a Google Meet space for a 30-minute sync and give me the join link.
> 2. Generate a Meet link for tomorrow's product review and summarize how to share it.
> 3. List recent conference records I can access and summarize who joined the latest one.
> 4. Create a Meet space with a clear name for the client onboarding call.
## Best practices
* If the meeting must appear on the calendar, say that explicitly (Calendar connector may also be needed).
* Confirm who should receive the link before broadcasting it.
* In agents, define whether Meet is only for link creation or also for post-meeting follow-up.
## Troubleshooting
Reconnect and ensure the Google account can authorize Meet. Workspace admins may need to allow the app.
Reconnect Google Meet in Connectors after password, 2FA, or admin policy changes.
Those resources may be unavailable for the account or meeting type. Verify access in Google Meet/Drive.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Google Sheets
Source: https://docs.tess.im/en/google-sheets
The **Google Sheets** connector integrates Tess with Google Sheets. Once connected, the AI can consult spreadsheet data, help structure reports, and support operational updates inside chats and agents.
Google Sheets is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Google account with access to the spreadsheets you need.
* Permission to authorize Google Sheets OAuth scopes.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Google Sheets** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Google Sheets** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Read spreadsheet data** from accessible files and tabs
* **Analyze metrics and trends** to produce summaries
* **Update cells or append rows** when write access is available
* **Support operational reporting** from live sheet data
* **Help teams turn tables into decisions** faster
## Example prompts
> 1. Analyze the leads spreadsheet and tell me which contacts had no follow-up in the last 7 days.
> 2. Read the monthly metrics sheet and generate an executive summary of the main deviations.
> 3. Append a row with today's sales total to the Daily Close tab.
> 4. Which columns look incomplete in the onboarding tracker?
## Best practices
* Share the spreadsheet name or link context when several files look similar.
* Ask for a preview before bulk writes.
* In agents, define whether Sheets is for analysis, reporting, or data entry.
## Troubleshooting
Reconnect and confirm the Google account can authorize Sheets. Workspace admins may need to allow the app.
Reconnect Google Sheets in Connectors after credential or policy changes.
The connected account may be viewer-only. Use an account with edit access.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Grok 4.6
Source: https://docs.tess.im/en/grok-4-6
Grok 4.6 (xAI) is available in Tess for **long-running agents, coding, knowledge work, and polished visual/interactive deliverables**. It is a post-training upgrade on the Grok 4.5 base — same price, stronger agentic coding.
| **Model IDs**
Frontier |
## What changed vs Grok 4.5
| | Grok 4.5 | Grok 4.6 |
| ------------------------- | -------------------------- | ---------------------------------- |
| Base | Grok 4.5 | Same base (extended post-training) |
| Context | 500K | 500K |
| DeepSWE v1.1 | 54% | **65.9%** |
| Terminal-Bench v3.0 | 15.7% | **26%** |
| APEX-Agents | 47.1% | **57.5%** |
| Reasoning in Tess | low / medium / high | low / medium / high |
| Tess credits / 100 tokens | 0.096 in / 0.288 out | **0.096 in / 0.288 out** |
| Modalities | Text + image in → text out | Text + image in → text out |
Native **reasoning**, **tools** (function calling, web search, code execution), and **image input**. Knowledge cutoff: February 2026.
## Pricing (Tess credits)
Values follow [Models and Costs](/en/models-and-cost) (credits per 100 tokens). Same rate across reasoning levels:
| Model | Input / 100 tokens | Output / 100 tokens |
| --------------- | ------------------ | ------------------- |
| Grok 4.6 Low | 0.096 | 0.288 |
| Grok 4.6 Medium | 0.096 | 0.288 |
| Grok 4.6 High | 0.096 | 0.288 |
> **Screenshot placeholder — model picker:** Capture the chat model selector with **Grok 4.6** (Low / Medium / High) visible.
## Ideal use cases in Tess
1. Long-running agents — multi-step research and execution without losing the thread
2. Agentic coding — codebase changes with +12 pts DeepSWE vs 4.5
3. Knowledge work on business documents
4. Interactive prototypes and polished deliverables
5. Multi-agent setups — High reasoning for the hardest subagents
6. Long sessions (500K context) without switching models
**Best practices**
* Start on **Medium**; move to **High** only when the task needs longer tool loops or harder coding.
* Price matches Grok 4.5 — upgrade the default on existing agents when you want the coding/agent gains at no extra credit cost.
* Very long prompts on the provider side can cost more; keep context scoped when you can.
See also: [Models and Costs](/en/models-and-cost) · [Introducing Grok 4.6 (xAI)](https://x.ai/news/grok-4-6).
# History
Source: https://docs.tess.im/en/history
The Tess History is where all interactions with AI are automatically recorded. It allows you to revisit conversations, organize content, and track platform usage, both at an individual and administrative level.
### **What is it?**
The History gathers all chats and executions made on Tess.
In practice, it works as:
* A complete record of conversations
* A reusable context repository
* A source for audit and usage control
Each conversation is automatically saved and can be reopened at any time, maintaining all the context already built.
### **Where is the history located?**
On the left side of the main screen, you will find the list of your chats organized chronologically. Each new chat is automatically saved and receives a name generated by Tess itself, based on the beginning of the conversation (which can be renamed).
This way, you can:
1. Reopen previous conversations: click on any conversation in the list to open the full history. You can continue the conversation exactly from where you left off, reusing all the context already built.
2. Organize in folders: to keep everything organized, you can create folders and group conversations, for example, by theme (e.g.: "Marketing", "Legal", "Internal Support"), by project (e.g.: "Q3 Launch", "Client Onboarding"), by client, etc.
3. Rename or delete chats: If any assigned name is not ideal, or if it is following a specific pattern, you can rename it. Or, if a chat has no relevance and you want to delete it, you can do so. Remember that this process is not reversible.
4. Reuse contents: By revisiting conversations, you can copy important excerpts already produced, turn old answers into documents, or use previous conversations as a base for new prompts.
Take advantage of the Conversation History, as it is your memory panel within Tess AI: everything is recorded, organized, and easy to find.
####
# HubSpot
Source: https://docs.tess.im/en/hubspot
Connect HubSpot to Tess to work with CRM contacts, deals, and pipeline context from chat and agents.
The **HubSpot** connector integrates Tess with HubSpot CRM. Once connected, the AI can look up contacts and companies, follow deals, and support sales or success routines inside chats and agents.
HubSpot is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A HubSpot account with access to the portal/data you need.
* Permission to authorize the HubSpot app for that portal.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **HubSpot** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **HubSpot** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search contacts, companies, and deals** in your CRM
* **Summarize pipeline status** and next steps for opportunities
* **Create or update CRM records** when the account has write access
* **Support follow-ups** with context from notes, properties, and deal stages
* **Help sales and CS teams** act without switching tools
## Example prompts
> 1. Find the HubSpot deal for Acme and summarize stage, amount, and next step.
> 2. List contacts created this week with no owner assigned.
> 3. Update the Acme deal note with today's discovery call summary.
> 4. Which open deals are stuck in Negotiation for more than 14 days?
## Best practices
* Name the company/deal clearly to avoid duplicates.
* Ask for confirmation before updating CRM fields.
* In agents, define whether HubSpot is for lookup, pipeline reporting, or CRM updates.
## Troubleshooting
Confirm you are authorizing the correct HubSpot portal and that your role can grant app access.
Reconnect HubSpot in Connectors after password or permission changes.
The connected user may lack permission on that object. Use an account with the required CRM scopes.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Image Generation
Source: https://docs.tess.im/en/images
Generate images directly in Tess chat using the leading visual AI models on the market. You enable the Images tool, choose the model, and describe what you want to see. The LLM helps you write the prompt and triggers the image AI — the result appears in the chat itself, integrated with the context of the conversation.
### **What is it?**
The Images tool in chat allows you to:
1. Create images from text (prompt)
2. Recreate the same image in different models
3. Apply quick functions such as:
* Remove background (remove background)
* Upscale image (improve resolution)
* SVG vectorize (convert to vector)
All of this without leaving the conversation: the previous context (brand, visual reference, persona, post objective, etc.) is used by the LLM to suggest better prompts and faster adjustments.
### **How to use it?**
Locate the tools button and the images option.
Another button will open where we will see the AIs and other features available for selection. You can test the same prompt across different models to compare styles and quality.
Write in natural language what you want:
"I want a minimalist Instagram post about mental health, light background, female character, flat style"
Depending on your request, the selected text model (LLM) may ask you quick questions about colors, format, and audience to build an optimized prompt for your needs. Share your ideas and let the LLM do the rest. It will write the prompt and trigger the image AI automatically; you don’t need to leave the chat or access another panel. That’s the power of multi-model collaboration!
In the example above, ChatGPT 5.2 helped us structure the prompt:
> *Minimalist Instagram post about mental health, clean light off-white background with lots of negative space, flat vector illustration style. Center-left a calm female character (adult woman) sitting cross-legged in a simple pose, eyes closed, gentle smile, hands on knees, subtle breathing lines near chest. Simple shapes, smooth pastel palette (sage green, muted blue, soft terracotta), thin outlines, no gradients, no textures, no shadows. Add a small abstract plant and a soft rounded shape behind her for balance. No text, no logos, no watermark. Modern, soothing, Scandinavian minimal design. High resolution, crisp edges.*
Notice that the prompt asks for the image with no logos, text, or watermark. In other words, whenever you want images with specific details or text, share it in the chat so the text model can help you!
The generated image appears directly in the conversation.
You can comment on it, ask for variations, change colors, adjust style, etc.
When you hover your mouse over the image, icons appear. From left to right, they represent:
1. Download: download the generated image to your device
2. Information: see the prompt, model, and image generation cost
3. Upscale: improve the image quality by 2x
4. Remove background: remove the background with AI, generating a PNG version
5. Vectorization: generate a vector of this image in SVG
6. Open image: to view it better, open it and see the details of your image
One of the differentiators is being able to:
* Generate the image with one model (e.g., Nano Banana).
* Then choose another model (e.g., Ideogram 4, Seedream 5, or Grok Imagine).
* Ask: "recreate it with the same aesthetic, but with the character standing up drinking tea".
The LLM reviews the prompt and the context and calls the new model automatically to generate the image.
### **Featured image models in chat**
Beyond the models already in your tool picker, these options are available when enabled on the agent:
| Model | Best for | Notes |
| ------------------------- | ----------------------------------------- | -------------------------------------------------------------------------- |
| **Ideogram 4** | Logos, posters, covers with readable text | Tiers: Fast, Balance, Quality |
| **Seedream 5 Pro / Lite** | Text-to-image and reference-guided edits | Pro: up to 10 refs (1K/2K). Lite: up to 14 refs, 2K/3K, sequential batches |
| **Grok Imagine Image** | Fast drafts and higher-quality stills | Fast and Quality tiers |
**Screenshot placeholder — image model picker:** Capture the Images tool picker showing **Ideogram 4**, **Seedream 5 Pro/Lite**, and **Grok Imagine** in the list (chat → Tools → Images).
### **Extra functions (after image processing)**
In addition to generating images from scratch, you can use specific functions directly through the chat:
Automatically removes the background from an image. Useful for cutting out products, creating stickers, building compositions in social media templates
Quick upscale increases resolution by 2x from the image hover actions. Useful for sharper assets in presentations and light print prep.
AI upscale that can invent or enhance details (2x–16x), with optional prompt guidance. Best for art, illustration, and stylized marketing. Do **not** use when you need faithful photo/product reproduction — use Precision instead.
Faithful super-resolution without creative hallucination (scale 2–16). Flavors: `sublime` (art/logos), `photo`, `photo_denoiser`. Best for product photos, logos, and print-ready DPI workflows.
Converts logos, icons, or simple drawings into vector format (SVG). Useful for responsive logos, icons in interfaces, and adjustments in vector design tools.
When an edit or upscale has a single reference image, open the result in TESS Computer and use compare mode to slide between the original and the output for visual QA.
**Screenshot placeholder — Professional Upscale:** Capture the tool picker under **Professional Upscale** with **Creative** and **Precision** visible.
**Screenshot placeholder — before/after compare:** Capture the TESS Computer drawer in compare mode with the slider between original and upscaled/edited image.
### **Quick usage examples in chat**
1. Instagram post
"I want an image for an Instagram post about anxiety, minimalist style, light background, with an illustration of a person taking a deep breath, in blue and lilac colors."
2. Image with readable text
"Create an e-book cover in Portuguese with the title 'Guia Prático de IA para Negócios', modern style, purple and white colors, no photos of people."
### \\
Advantages of creating images directly in chat
* Continuous context: the LLM remembers the conversation (brand, persona, campaign) and uses it to improve prompts.
* Fast iteration: you adjust text, color, style, model — all in the same thread.
* Real multimodality: text, image, video, music, and audio in the same flow.
* Model testing: generate with one model, switch to another, and compare styles.
* Integrated post-processing: remove background, upscale, and vectorize without leaving the chat.
Tips!
Always indicate:
* image objective (feed, story, thumb, slide)
* style (realistic, illustrated, flat, 3D, minimalist)
* main colors
* whether you need text in the image (and what text)
When testing different models:
* keep the same base prompt
* ask explicitly: "use the same prompt, but generate it with model X"
# Integrations
Source: https://docs.tess.im/en/integrations
*Turn any chat conversation into real actions: send emails, create tasks, update spreadsheets, and trigger automation flows — all in natural language.*
### **Integrations in the Tess Chat: What Is It?**
Integrations is the new Tess AI feature that turns any chat conversation into a trigger for powerful automations. Now, you can connect Tess AI with thousands of applications through automation platforms such as **Zapier, Make, and N8N**.
To access it, simply click on Tools > Integrations and then choose the platform where you configured your automation!
Always remember to activate the tool before using it!
***Why is this relevant?***
Even on the best AI platforms in the world, it was not yet possible to **execute activities** across multiple external platforms in an easy way. Existing actions were limited, and users had to switch between multiple tools to get a task fully done.
Instead of just "chatting" with the AI, you actually execute tasks in external tools, without leaving the chat. In other words, Tess becomes the Trigger needed to activate your automation!
* Ease of use: Execute complex automations using natural language.
* Universal connection: Access various apps via Zapier, Make, and N8N.
* Fewer errors: Tess guides the configuration process end-to-end, supported by the LLM.
* Smart context: Tess understands the conversation and formats data appropriately for each automation.
* Send emails directly through Gmail or Outlook
* Create tasks in Trello, Asana, or Notion
* Update records in Salesforce, HubSpot, or Pipedrive
* Notify the team on Slack, Teams, or Discord
* Generate documents, update spreadsheets, process payments, and much more
**Automation Platforms**
Zapier, Make, and N8N are three of the largest automation platforms in the world!
They allow you to connect more than 10,000 applications and create workflows between them, without code.
Examples of app categories:
* CRMs: Salesforce, HubSpot, Pipedrive, Zoho
* Email: Gmail, Outlook, Microsoft 365
* Communication: Slack, Teams, Discord, Telegram
* Management: Notion, Trello, Asana, Monday
* Financial: Stripe, PayPal, QuickBooks
And thousands of others.
However, if the platform you want to work with does not have integration with Zapier, Make, or N8N, you can directly integrate any platform or API that accepts **HTTP requests** through the Tess chat, without any hassle!
Access and check our API documentation at:
### **Use Cases**
With Integrations, you can scale various projects. In practice, your company can virtually connect with the main digital tools on the market to automate processes, such as:
* Automatic proposal sending
* Personalized follow-ups
* Meeting confirmations
* Internal announcements
* Selection process notifications
* Training reminders
* Periodic reports
* Project updates
* Stakeholder communication
* Content delivery
* Event confirmations
* Segmented newsletters
* Mass publishing of personalized posts for each social network
That's right — the possibilities are endless!
**Important!**
Avoid sharing secrets such as passwords and API keys — this applies to any platform in the world!
\
The guide below shows in practice how to configure and make the most of our Integrations Tool in the Tess chat:
[Access the Practical Guide](https://docs.google.com/document/d/e/2PACX-1vS-jKoJ_vGLvw_Nr18c1Ix7UcTJfHQ9Ae569aElCKhP1hNupOXr2rS07-3HE8x3QUWZ3Wh1DDx_9nzz/pub)
Tess Integrations combines the power of a chat with multiple text and image AIs with the universal connectivity of platforms like Zapier, Make, and N8N. It is a solution that is both powerful and accessible.
If you have any questions, our team is available to help at: [support@tess.im](mailto:support@tess.im).
# Internet
Source: https://docs.tess.im/en/internet
As a rule, language models (LLMs) have a “cutoff date” in their training data, so they aren’t designed to provide real-time information. Tess AI’s Internet Tools break this limitation by connecting the chat to the web in real time. This way, the AI can search for up-to-date information, consult reliable sources, and bring answers based on what’s happening now.
### **Enabling the Internet Tool**
Open the chat and click the Tools icon in the message box, enable the internet option, and then see which engine you want to use at that moment.
See below what each search engine does and when to use them:
\
It’s the standard web search tool, similar to using Google or Bing inside Tess. It runs a direct search based on your command and returns information from the first results.
When to use
* Direct, factual questions
* Recent news and current events
* Quick lookups when you want an objective answer
Usage examples
* “What was yesterday’s game result between Team A and Team B?”
* “What’s the dollar exchange rate today?”
* “Summarize today’s main news in Brazil.”
* “What are the swimwear market trends for year X”
\
It’s like having a dedicated research assistant. Instead of a quick search, the AI, Deep Research consults multiple sources, compares information, organizes and synthesizes different pieces of content, and delivers a more robust report.
When to use
* To research and understand complex topics in depth
* When preparing reports, analyses, and strategic documents
* When you want different perspectives on the same subject
Usage examples
* “Do deep research on the impacts of artificial intelligence on the job market, broken down by sector.”
* “Build a report on Company X’s main competitors, focusing on products, positioning, and recent marketing strategies.”
\
It’s GPT’s own search engine, similar to Search Engine, but it uses GPT’s feature (which accesses Bing). Here it also searches, consolidates, and produces a cohesive answer.
\
A tool that focuses the search on public information from social media profiles (such as X/Twitter, LinkedIn, Instagram, etc.). Social network search tools can’t access private profiles.
When to use
* To find biography information about individuals
* Publicly available social media information about companies
Usage examples
* “What are the relevant publicly available details about Company X on LinkedIn”
* “How many posts, followers, and what is the bio of profile X on Instagram”
\
It’s the academic research tool that prioritizes searching for scientific articles and peer-reviewed papers in databases like Google Scholar and similar sources.
When to use
* Academic work, theses, scientific articles
* Projects that require evidence and formal references
* When you need to cite studies, statistics, or systematic reviews
Usage examples
* “Find academic articles about the effects of meditation on reducing anxiety.”
* “What is the most recent research on using graphene in batteries?”
**Remember:**
Be clear about the objective and explain what you want as the output:
* “I want a summary of topic XYZ in 5 bullet points”
* “I only want numerical data with sources”
* “Cite the main sources used”
Combine research with the intelligence of AI and, after the search, ask the LLM to compare viewpoints, generate actionable insights, and adapt the information to your reality (e.g., “apply this to the context of a B2B SaaS startup”).
That way, you use Tess not only as a language model, but as a true research assistant connected to the real world and kept up to date.
# Kimi K3
Source: https://docs.tess.im/en/kimi-k3
Kimi K3 (Moonshot AI) is the largest **open-weight** frontier model in Tess: **2.8T** total parameters (**104B** active per token), **native vision**, and **1M** context. Use it for long-horizon coding, agents, and multimodal knowledge work.
| **Model IDs**
Frontier (open-weight) |
## What changed vs Kimi K2.6
| | Kimi K2.6 | Kimi K3 |
| ------------------------- | -------------------- | --------------------------- |
| Total / active params | — | **2.8T / 104B** |
| Context | 1M | 1M |
| Vision | Yes | Native text + image + video |
| Reasoning in Tess | — | low / high / **max** |
| Tess credits / 100 tokens | 0.042 in / 0.196 out | **0.1596 in / 0.798 out** |
MoE architecture (896 experts, 16 active per token). Tess exposes three reasoning levels; **Max** is the deepest (Moonshot’s default at launch).
## Pricing (Tess credits)
Values follow [Models and Costs](/en/models-and-cost) (credits per 100 tokens). Same rate across reasoning levels:
| Model | Input / 100 tokens | Output / 100 tokens |
| ------------ | ------------------ | ------------------- |
| Kimi K3 Low | 0.1596 | 0.798 |
| Kimi K3 High | 0.1596 | 0.798 |
| Kimi K3 Max | 0.1596 | 0.798 |
Cached context reads are billed at a lower rate than a full input pass.
> **Screenshot placeholder — model picker:** Capture the chat model selector with **Kimi K3** (Low / High / Max) visible.
## Ideal use cases in Tess
1. Long-horizon coding — large repos, multi-file refactors, code agents
2. Persistent agent workflows with tool loops
3. Multimodal knowledge work (documents, images, and video in one context)
4. Deep reasoning with **Kimi K3 Max**
5. Open-weight frontier workloads that still need frontier-class capacity
6. Long sessions (1M context) without switching models
**Best practices**
* Use **Low** for drafting and high-volume passes; **High** as the default; reserve **Max** for planning-heavy tasks.
* K3 costs more than K2.6 — don’t swap it in as a blanket default on cheap extraction jobs.
* Lean on cached context in long threads to keep input cost down.
See also: [Models and Costs](/en/models-and-cost) · [Kimi K3 (Moonshot)](https://www.kimi.com/blog/kimi-k3).
# Linear
Source: https://docs.tess.im/en/linear
The **Linear** connector integrates Tess with Linear issue tracking and project planning. Once connected, the AI can create and update issues, check project status, and support engineering routines inside chats and agents.
Linear is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Linear account with access to the workspace you want to use.
* Permission to authorize third-party apps in that Linear workspace.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Linear** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Linear** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Create and update issues** with title, description, priority, and assignees
* **Search and list issues** by team, project, status, or labels
* **Track projects and cycles** to summarize progress and blockers
* **Comment on issues** without leaving Tess
* **Organize work** for engineering, product, and support routines
## Example prompts
> 1. List open issues assigned to me in the ENG team and group them by priority.
> 2. Create a bug in Linear titled 'Login timeout on Safari' and assign it to me.
> 3. Summarize what changed this week in the Connectors project and highlight blockers.
> 4. Find issues labeled 'customer' that are still In Progress and suggest next steps.
## Best practices
* Name the team/project when you have more than one context.
* Ask for a draft issue first when the request is ambiguous.
* In agents, define whether Linear is for intake, triage, or status reporting.
## Troubleshooting
Confirm you are in the correct Linear workspace and that third-party apps are allowed.
Reconnect Linear in Connectors. Tokens can expire after password or permission changes.
The connected account may lack access. Connect with an account that can view that team.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# LinkedIn
Source: https://docs.tess.im/en/linkedin
Connect LinkedIn to Tess to support professional research and content workflows from chat and agents.
The **LinkedIn** connector integrates Tess with LinkedIn. Once connected, the AI can help with professional research and content-related tasks inside chats and agents, within the permissions of the connected account.
LinkedIn is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A LinkedIn account with access to the data or pages you need.
* Permission to authorize the LinkedIn app for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **LinkedIn** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **LinkedIn** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Support professional research** for people, companies, or topics you can access
* **Help draft posts and updates** for review before publishing
* **Summarize public professional context** relevant to a go-to-market task
* **Assist recruiting or sales prep** with clearer briefing notes
* **Keep LinkedIn workflows closer to Tess**
## Example prompts
> 1. Draft a LinkedIn post announcing our new Connectors docs and keep it under 1200 characters.
> 2. Prepare a short brief about Company X for an outbound sales call.
> 3. Suggest 5 post angles about AI agents for operations leaders.
> 4. Summarize the key talking points I should use when engaging prospects in SaaS.
## Best practices
* Be explicit about audience and tone for drafts.
* Ask for a preview before publishing anything.
* In agents, define whether LinkedIn is for research, drafting, or both.
## Troubleshooting
Reconnect with the LinkedIn account that has the needed access and approve the requested permissions.
Reconnect LinkedIn in Connectors after password or app permission changes.
Some LinkedIn data is restricted by account type or permissions.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Manage Files
Source: https://docs.tess.im/en/manage-files
How many times have you asked AI to analyze a text and then had to copy, paste, and adjust everything in the original file? Manage Files was created to eliminate this rework. Instead of just suggesting changes, Tess can edit the file directly and generate a new version ready for download.
### **What Manage Files is**
Manage Files is a tool that allows the AI to:
* read and generate documents
* apply requested changes
* save a new version of the file, preserving formatting and layout as much as possible
It works similarly to Deep Analysis in “execution mode”: you ask in natural language and the AI creates a virtual machine, runs the task (usually via structured document processing), delivering the edited file at the end.
Use it whenever you want Tess to “do it in the file”, not just “tell you how to do it”.
**File format**
If you want to use a file as a base, remember to use an editable version, meaning: DOCX, PPTX. After all, a PDF can’t be edited, only the existing content can be consumed.
Practical examples:
> * "Translate all the text in this presentation to Spanish, keeping the original formatting."
> * "Replace the old logo with the new one on all slides."
> * "Standardize all titles to Arial font, size 24, bold."
> * "Find all occurrences of 'Company A' and replace with 'Company B'."
> * "Add a header with 'Confidential Report – Draft' on all pages."
> * "Create a new column called 'Status' and fill all rows with 'To Process'."
### **Manage Files vs. Deep Analysis (essential difference)**
* Objective: analyze shared documents, modify them based on them, or even generate a new file from scratch, only with the prompt command in the chat.
* Result: a new file made available for download within the chat itself.
* Objective: analyze/calculate/understand data with precision (especially spreadsheets/CSVs).
* Result: an analysis in text, tables, and/or charts (not necessarily a final edited file, but it can also generate a new file).
### **How to use it (step by step)**
1. In chat, click the Tools button (icon next to the message box)
2. Select "Manage Files"
3. Attach the file you want to edit
4. Give the instruction clearly and directly
5. Wait for processing and download the new version of the file
Manage Files is a productivity multiplier and delivers the file ready, drastically reducing manual tasks. Instead of receiving only recommendations, you receive the final edited result ready to use.
# Marketplace
Source: https://docs.tess.im/en/marketplace
Tess's Marketplace is one of the great pillars of the platform. It allows users to access thousands of agents created by the Tess community and made available to the public.
Any user can create an agent and make it public, available in the Tess Marketplace. More than that, they can activate monetization for that agent and turn it into an additional source of income.
### **What is it?**
The Marketplace is a showcase of agents ready to use. Any agent marked as Public in Visibility can appear in the Marketplace. You can filter by category, use case, language, popularity, etc.
When you find something interesting, you can test it, add it to your workspace (as a copy, if enabled by the owner), and then adapt the prompt, Knowledge Base, and settings to fit your needs.
### **Why is it important?**
Instead of starting from scratch, you start from a ready-made agent and adjust it.
See how other companies and creators structure prompts, Knowledge Base, and settings.
Find agents focused on specific niches (legal, marketing, CS, financial, education, etc.).
### **How to access the Marketplace**
1. Go to Agent Studio
2. If you want to search for an agent, use the search bar. Use keywords related to your use case or Workspace names.
3. To access the Marketplace, click on Explore Marketplace ([Marketplace link](https://tess.pareto.io/pt-BR/dashboard/user/ai))
4. Browse or use the filters by category (Support, Sales, Marketing, Data, Education, etc.).
5. Open the agent you want to test and use it normally.
6. For those that have the clone or purchase option enabled, if it makes sense, you can proceed and create a copy for your Workspace, where you will be able to edit everything.
**Best practices**
* Use the Marketplace as a starting point, not as a "set it and forget it" solution: always adapt it to your context.
* Read the descriptions and limitations of each agent.
* If you publish your own agents, clearly describe:
* what it is for
* what it does well
* known limitations
# Max Mode
Source: https://docs.tess.im/en/max-mode
Max Mode was created for when you need to expand the context window to the maximum capacity of the AI for long, dense, or complex tasks. It is an advanced feature that allows you to extract the full potential of the chosen model, increasing the context and processing capacity for that specific interaction or set of interactions.
## What is Max Mode?
Think of Max Mode as the "sport mode" of a car: it prioritizes power and depth, even if that comes at a higher cost.
As a rule, Tess uses a context window of 32,000 tokens (\~24,000 words). In practice, when you activate Max Mode, the AI starts using the largest context window available for the chosen model.
The context window corresponds to the model's "short-term memory". With Max Mode, the AI's performance will not be affected in long conversations and extensive content, reducing the chance of hallucination or forgetting information in large projects.
When you activate the tool, you get:
* More context: the AI considers more information from the conversation and attached materials.
* More consistency: improvement in tasks that require continuity (decisions, rules, characters, criteria, code).
* More depth: increases the capacity for analysis and synthesis in large texts.
> **When to use Max Mode (ideal cases)?**
>
> 1. Analysis of long documents: Use it when you are working with extensive PDFs (reports, manuals, proposals), complex contracts, documents with many details, attachments, or sections. This way, you will improve information retention and cross-referencing throughout the chat.
> 2. Code and debugging: In this case, it is ideal when there are multiple files, snippets, and dependencies, or you are fixing bugs with accumulated context, or you need to maintain the architecture and style standards of the project.
> 3. Long and consistent content: Use it when writing book chapters, long scripts, theses, dense articles, or training materials. This will give you more consistency in concepts, style, and structure across many pages.
> **When NOT to use it?**
>
> For quick and everyday tasks, the standard mode is usually better — these include simple questions, short emails, small summaries, quick text adjustments, operational support responses, among others.
**Watch out for cost and performance!**
Maximum power comes with higher consumption. That is, when using Max Mode, keep in mind that:
1. credit consumption tends to be higher
2. the response may take a little longer, as the AI needs to reprocess more context with each message
Therefore, use Max Mode strategically: turn it on when you need depth or continuity, and turn it off when you go back to simple tasks.
# Memories
Source: https://docs.tess.im/en/memories
Tess Memories allow you to save, organize, and reuse important information in the form of collections. They work as "knowledge folders" that you activate before each conversation, ensuring the AI responds with context, consistency, and alignment with your work or your team's work.
### **What is it?**
A Memory Collection is a set of structured information (texts, instructions, data, or rules) that you provide to the AI before starting a conversation.
In practice:
* You write memories (e.g.: client context, tone of voice, internal rules)
* Organize them into thematic collections
* Activate these collections in the chat
* The AI automatically takes this content into account in its responses
Think of it as a "reusable context package" that you hand over to the agent before each task.
Tess Memories allow you to save, organize, and reuse important information in the form of collections. They work as "knowledge folders" that you activate before each conversation, ensuring the AI responds with context, consistency, and alignment with your work or your team's work.
### **What is it?**
A Memory Collection is a set of structured information (texts, instructions, data, or rules) that you provide to the AI before starting a conversation.
In practice:
* You write memories (e.g.: client context, tone of voice, internal rules)
* Organize them into thematic collections
* Activate these collections in the chat
* The AI automatically takes this content into account in its responses
Think of it as a "reusable context package" that you hand over to the agent before each task.
You can decide, at any time, which memory collections you want to keep active/inactive for each job. It is fully modular. These memories can be used in new conversations, without the user needing to repeat everything every time.
## Why is it important?
* **Real personalization:** Tess responds taking history (memory) into account, not just the current message.
* **Less repetition:** The user does not need to provide the same data at each interaction.
* **Context for the team:** Organized memories help both the AI and the human team maintain the same level of service, even when agents change.
* **Work organization:** you can organize your memories by team, by project, by client, or however you prefer, to bring versatility to your way of working with AI.
## Configuring and Managing Memories
* Open the Chat screen
* Locate the Memory Collections icon in the upper right corner\\
* Select an existing collection or create a new one, according to your needs\\
* Create memories and a collection\\
* Remember to activate the collection — a number will appear on the icon and active collections will be marked
In the Memories icon, you can:
* Activate or deactivate memory collections
* Create new collections segmented by use case
* Review, edit, or remove existing memories
### **Import memories from other AIs**
If you already built personalization in ChatGPT, Claude, Gemini, or a similar assistant, you can bring that context into Tess without retyping everything.
1. Open **Personal Settings → Memories** (or the optional import step during onboarding, when enabled).
2. Start **Import memories**.
3. Copy the guided prompt Tess shows, paste it into your other AI, and export the answer.
4. Paste the export back into Tess and run **Process**.
5. Wait for the completion summary (how many memories were created). You can **Follow in chat** while it runs.
Imported memories belong to **you** in the **current workspace**. Skipping import never blocks onboarding. Access depends on plan/role (Memory Import feature). There is a daily limit on how many imports you can start, and pasted text has a maximum length.
> **Screenshot placeholder — memory import:** Capture (1) the Import card on Personal Settings → Memories, and (2) the two-step modal (copy prompt → paste export) with progress/completion.
After activating a collection, you can start or continue the conversation normally in the chat. Notice whether the LLM is using the memory information to complement responses (when it makes sense).
### **Collection Sharing**
Tess offers 4 sharing options, with different levels of control:
*Only you access and edit*
When you create a collection without sharing, it is entirely yours. Ideal for personal contexts, your own methodologies, or confidential information.
*Anyone with the link imports a copy*
Generate a public link. Whoever accesses it can import a full copy to their own account. Each person has their own independent version after importing.
*Live access — permanent connection*
All members have real-time access. Any update by the owner appears immediately for everyone in the next chat. Define who can read and who can edit.
*The entire company has access*
Ideal for knowledge that everyone should have: brand values, product manual, internal glossary. The admin controls the permissions.
### Sharing management
The sharing flow has been improved with more control and clarity:
* Organized management modal to view access
* Granular permissions (view or edit)
* Prevention of duplicate invitations
* Active link control
* Preservation of the origin of shared collections
To share, simply:
When you hover over the collection, the buttons will appear — just locate the share button and begin the settings:
If you want to assign a prefix, that is possible, as well as choosing the permission level — view or edit. After configuring this, just generate your link.
**Best Practices**
* Clearly define what type of information can become a memory — and what should never be saved (for example, sensitive data, passwords, information that violates privacy or compliance policies).
* Use different collections for different contexts (one for support, one for sales, one for internal projects).
* Periodically review memories and collections to remove anything outdated or irrelevant, keeping only what truly helps with personalization and service quality.
* Prefer shared collections to standardize teams.
### Important notes
* Active memories consume tokens (they are part of the context sent to the AI)
* The more active collections, the higher the potential cost
* Avoid storing: Passwords; Sensitive data; or Confidential information without access control
* Team/workspace sharing is synchronized in real time
Memories transform Tess into a truly contextual system. With well-structured collections and the new sharing model, you reduce repetition, increase consistency, and scale AI usage with much more control.
### **Collection Sharing**
Tess offers 4 sharing options, with different levels of control:
*Only you access and edit*
When you create a collection without sharing, it is entirely yours. Ideal for personal contexts, your own methodologies, or confidential information.
*Anyone with the link imports a copy*
Generate a public link. Whoever accesses it can import a full copy to their own account. Each person has their own independent version after importing.
*Live access — permanent connection*
All members have real-time access. Any update by the owner appears immediately for everyone in the next chat. Define who can read and who can edit.
*The entire company has access*
Ideal for knowledge that everyone should have: brand values, product manual, internal glossary. The admin controls the permissions.
### Sharing management
The sharing flow has been improved with more control and clarity:
* Organized management modal to view access
* Granular permissions (view or edit)
* Prevention of duplicate invitations
* Active link control
* Preservation of the origin of shared collections
To share, simply:
When you hover over the collection, the buttons will appear — just locate the share button and begin the settings:
If you want to assign a prefix, that is possible, as well as choosing the permission level — view or edit. After configuring this, just generate your link.
**Best Practices**
* Clearly define what type of information can become a memory — and what should never be saved (for example, sensitive data, passwords, information that violates privacy or compliance policies).
* Use different collections for different contexts (one for support, one for sales, one for internal projects).
* Periodically review memories and collections to remove anything outdated or irrelevant, keeping only what truly helps with personalization and service quality.
* Prefer shared collections to standardize teams.
### Important notes
* Active memories consume tokens (they are part of the context sent to the AI)
* The more active collections, the higher the potential cost
* Avoid storing: Passwords; Sensitive data; or Confidential information without access control
* Team/workspace sharing is synchronized in real time
Memories transform Tess into a truly contextual system. With well-structured collections and the new sharing model, you reduce repetition, increase consistency, and scale AI usage with much more control.
## Using Memories via API
Authenticated memory API calls must include `x-workspace-id` (**required as of 2026-09-01**). Until then, omitting it falls back to the selected workspace (deprecated). After the cutoff, missing header → **422**. See [API Overview](/en/api-overview).
You can manage memories and apply them to agent executions directly through the API. The full flow involves three steps:
### Step 1 — Create a memory collection
```bash theme={null}
curl --request POST \
--url 'https://api.tess.im/memory-collections' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"name": "Customer data",
"description": "Profile information and preferences"
}'
```
Save the `id` from the response — you will use it in the next steps.
### Step 2 — Create memories in the collection
Add each memory record by passing the `collection_id` obtained in the previous step:
```bash theme={null}
curl --request POST \
--url 'https://api.tess.im/memories' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"memory": "The customer prefers formal communication and works in the financial sector.",
"collection_id": 123
}'
```
The created memory goes through an embedding process (semantic indexing). The `embedding_status` field starts as `pending` and changes to `succeeded` when it is ready to be queried. Wait for `succeeded` status before executing the agent to ensure the memory is found.
### Step 3 — Execute the agent with memory collections
When executing the agent, pass the `memory_collections` parameter with the IDs of the collections you want to activate:
```bash theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/YOUR_AGENT_ID/execute' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"memory_collections": [123],
"messages": [
{ "role": "user", "content": "How do you prefer me to communicate with you?" }
]
}'
```
**How memory injection works:** Tess uses semantic search (RAG) to automatically select the most relevant memories from the collection based on the conversation content. Only memories with high semantic similarity are injected into the agent context — you do not need to specify which memories to use, just which collection to activate.
# Mobile App
Source: https://docs.tess.im/en/mobile
The Tess app is the mobile version of the platform, available for download in:
For iPhone or iPad
Android smartphones and Tablets
You use the same account as the web version, with access to the same workspaces, agents, conversations, and main features.
## How to log in to the app
1. Step 1 – Open the app
Tap the Tess icon on your phone/tablet. On the first launch, you will be taken directly to the welcome/login screen.
2. Step 2 – Enter your credentials
For those who already use Tess on the web:
* Enter the same email and password you use on the web version
* If available, you can also sign in with your Google account
For new users:
* Tap "Create account"
* Fill in the required information
* Confirm your registration and then log in normally
### I forgot my password. What now?
* On the login screen, tap "Forgot my password".
* You will receive an email with instructions to reset your password.
* After creating the new password, go back to the app and log in again.
### Requirements and recommendations
1. Internet connection: The Tess app requires an active connection (Wi-Fi or mobile data) to work properly.
2. Storage space: Make sure your device has enough free space to install and update the app.
3. Notifications: You can enable app notifications in your phone's settings to receive important alerts, follow updates, and be notified of relevant events in your account.
### How the app works (compared to the web version)
The mobile experience is very similar to the web version, with an interface adapted for touch and smaller screens.
In the app, you can, for example:
* chat with text models in the chat
* use your agents
* use image, audio, video, music, and other tools directly from the chat
* access conversation histories and results, and much more
In summary: everything you already do on your computer, you can now do "in your pocket", with the same account and the same main features.
For any questions, contact our support team at: [support@tess.im](mailto:support@tess.im)
# Models and Costs
Source: https://docs.tess.im/en/models-and-cost
Understand exactly how the cost of each model available in Tess works according to its specifications.
The values below always represent the **lowest possible execution cost** for each model.
## Technical identifier (API Slug)
The **API Slug** column is the stable model identifier — the same value used in programmatic configuration (for example, `model_override` in Cowork JSON). Use the slug, not the display name.
For a guide with a JSON example, see also [Model slugs](/en/cowork/digital-employees/configuracao-detalhada/model-slugs).
## Text Models
| Model | Cost | API Slug |
| --------------------------- | ----------------------------------------------------------------------------- | --------------------------------- |
| ChatGPT 5.6 Terra | 0.112 credits per 100 input tokens 0.672 credits per 100 output tokens | `gpt-5.6-terra` |
| ChatGPT 5.6 Terra Low | 0.112 credits per 100 input tokens 0.672 credits per 100 output tokens | `gpt-5.6-terra-low` |
| ChatGPT 5.6 Terra High | 0.112 credits per 100 input tokens 0.672 credits per 100 output tokens | `gpt-5.6-terra-high` |
| ChatGPT 5.6 Terra Medium | 0.112 credits per 100 input tokens 0.672 credits per 100 output tokens | `gpt-5.6-terra-medium` |
| ChatGPT 5.6 Luna | 0.0112 credits per 100 input tokens 0.0672 credits per 100 output tokens | `gpt-5.6-luna` |
| ChatGPT 5.6 Luna Low | 0.0112 credits per 100 input tokens 0.0672 credits per 100 output tokens | `gpt-5.6-luna-low` |
| ChatGPT 5.6 Luna High | 0.0112 credits per 100 input tokens 0.0672 credits per 100 output tokens | `gpt-5.6-luna-high` |
| ChatGPT 5.6 Luna Medium | 0.0112 credits per 100 input tokens 0.0672 credits per 100 output tokens | `gpt-5.6-luna-medium` |
| ChatGPT 5.6 Sol | 0.224 credits per 100 input tokens 1.120 credits per 100 output tokens | `gpt-5.6-sol` |
| ChatGPT 5.6 Sol Low | 0.224 credits per 100 input tokens 1.120 credits per 100 output tokens | `gpt-5.6-sol-low` |
| ChatGPT 5.6 Sol High | 0.224 credits per 100 input tokens 1.120 credits per 100 output tokens | `gpt-5.6-sol-high` |
| ChatGPT 5.6 Sol Medium | 0.224 credits per 100 input tokens 1.120 credits per 100 output tokens | `gpt-5.6-sol-medium` |
| Claude 5 Sonnet | 0.056 credits per 100 input tokens 0.056 credits per 100 output tokens | `claude-5-sonnet` |
| Claude 5 Sonnet Low | 0.056 credits per 100 input tokens 0.056 credits per 100 output tokens | `claude-5-sonnet-low` |
| Claude 5 Sonnet Medium | 0.056 credits per 100 input tokens 0.056 credits per 100 output tokens | `claude-5-sonnet-medium` |
| Claude 5 Sonnet Hight | 0.168 credits per 100 input tokens 0.840 credits per 100 output tokens | `claude-5-sonnet-high` |
| Claude 5 Sonnet Xhigh | 0.056 credits per 100 input tokens 0.056 credits per 100 output tokens | `claude-5-sonnet-xhigh` |
| Claude 5 Sonnet Max | 0.056 credits per 100 input tokens 0.056 credits per 100 output tokens | `claude-5-sonnet-max` |
| Nvidia nemotron 3 Ultra | 0.011 credits per 100 input tokens 0.044 credits per 100 output tokens | `nvidia-nemotron-3-ultra-550b` |
| Nvidia nemotron 3 Super | 0.0056 credits per 100 input tokens 0.0280 credits per 100 output tokens | `nvidia-nemotron-3-super-120B` |
| Nvidia nemotron 3 Nano Omni | 0.028 credits per 100 input tokens 0.014 credits per 100 output tokens | `nvidia-nemotron-3-nano-omni-30B` |
| Grok 4.5 | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.5` |
| Grok 4.5 Low | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.5-low` |
| Grok 4.5 Medium | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.5-medium` |
| Grok 4.5 High | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.5-high` |
| Grok 4.6 Low | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.6-low` |
| Grok 4.6 Medium | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.6-medium` |
| Grok 4.6 High | 0.096 credits per 100 input tokens 0.288 credits per 100 output tokens | `grok-4.6-high` |
| Fugu Ultra High | 0.28 credits per 100 input tokens 1.68 credits per 100 output tokens | `fugu-ultra-high` |
| Fugu Ultra Xigh | 0.28 credits per 100 input tokens 1.68 credits per 100 output tokens | `fugu-ultra-xhigh` |
| Fugu Ultra Max | 0.28 credits per 100 input tokens 1.68 credits per 100 output tokens | `fugu-ultra-max` |
| GLM 5.2 | 0.067 credits per 100 input tokens 0.211 credits per 100 output tokens | `glm-5.2` |
| GLM 5.3 | 0.192 credits per 100 input tokens 0.603 credits per 100 output tokens | `glm-5.3` |
| GLM 5.3 Flash | 0.010 credits per 100 input tokens 0.034 credits per 100 output tokens | `glm-5.3-flash` |
| Claude Fable 5 | 0.56 credits per 100 input tokens 2.80 credits per 100 output tokens | `claude-fable-5` |
| Claude Fable 5.1 | 0.56 credits per 100 input tokens 2.80 credits per 100 output tokens | `claude-fable-5-1` |
| Claude Fable 5 Thinking | 0.56 credits per 100 input tokens 2.80 credits per 100 output tokens | `claude-fable-5-high` |
| Claude Fable 5 | 0.56 credits per 100 input tokens 2.80 credits per 100 output tokens | `claude-fable-5` |
| Claude Fable 5 Thinking | 0.56 credits per 100 input tokens 2.80 credits per 100 output tokens | `claude-fable-5-high` |
| Claude 4.8 Opus | 0.28 credits per 100 input tokens 1.40 credits per 100 output tokens | `claude-4.8-opus` |
| Claude 4.8 Opus Thinking | 0.28 credits per 100 input tokens 1.40 credits per 100 output tokens | `claude-4.8-opus-high` |
| Tess 6 | 0.396 credits per 100 input tokens 1.590 credits per 100 output tokens | `tess-6` |
| Consensus | 0,084 credits per 100 input tokens 0,672 credits per 100 output tokens | `consensus` |
| Consensus CN | 0,045 credits per 100 input tokens 0,143 credits per 100 output tokens | `consensus-cn` |
| Consensus US | 0,084 credits per 100 input tokens 0,672 credits per 100 output tokens | `consensus-us` |
| ChatGPT 5.5 | 0,28 credits per 100 input tokens 1,68 credits per 100 output tokens | `gpt-5.5` |
| ChatGPT 5.5 High | 0,28 credits per 100 input tokens 1,68 credits per 100 output tokens | `gpt-5.5-high` |
| ChatGPT 5.5 Medium | 0,24 credits per 100 input tokens 1,44 credits per 100 output tokens | `gpt-5.5-medium` |
| ChatGPT 5.5 Low | 0,28 credits per 100 input tokens 1,68 credits per 100 output tokens | `gpt-5.5-low` |
| Claude 4.7 Opus | 0,28 credits per 100 input tokens 1,40 credits per 100 output tokens | `claude-4.7-opus` |
| Claude 4.6 Sonnet | 0,17 credits per 100 input tokens 0,84 credits per 100 output tokens | `claude-4.6-sonnet` |
| Claude 4.5 Haiku | 0,048 credits per 100 input tokens 0,24 credits per 100 output tokens | `claude-4.5-haiku` |
| Gemini 3.5 Flash | 0,072 credits per 100 input tokens 0,432 credits per 100 output tokens | `gemini-3.5-flash` |
| Gemini 3.7 Flash | 0,036 credits per 100 input tokens 0,180 credits per 100 output tokens | `gemini-3.7-flash` |
| Gemini 3.8 Flash | 0,036 credits per 100 input tokens 0,180 credits per 100 output tokens | `gemini-3.8-flash` |
| Gemini 3.1 Pro | 0,096 credits per 100 input tokens 0,576 credits per 100 output tokens | `gemini-3.1-pro` |
| Gemini 3.1 Flash Lite | 0,012 credits per 100 input tokens 0,072 credits per 100 output tokens | `gemini-3.1-flash-lite` |
| Gemini 3 Flash | 0,028 credits per 100 input tokens 0,168 credits per 100 output tokens | `gemini-3-flash` |
| Grok 4.3 | 0,06 credits per 100 input tokens 0,12 credits per 100 output tokens | `grok-4.3` |
| Grok 4.3 Low | 0,06 credits per 100 input tokens 0,12 credits per 100 output tokens | `grok-4.3-low` |
| Grok 4.3 Medium | 0,06 credits per 100 input tokens 0,12 credits per 100 output tokens | `grok-4.3-medium` |
| Grok 4.3 High | 0,06 credits per 100 input tokens 0,12 credits per 100 output tokens | `grok-4.3-high` |
| Kimi K2.6 | 0,04 credits per 100 input tokens 0,19 credits per 100 output tokens | `kimi-k2.6` |
| Kimi K3 Low | 0,1596 credits per 100 input tokens 0,798 credits per 100 output tokens | `kimi-k3-low` |
| Kimi K3 High | 0,1596 credits per 100 input tokens 0,798 credits per 100 output tokens | `kimi-k3-high` |
| Kimi K3 Max | 0,1596 credits per 100 input tokens 0,798 credits per 100 output tokens | `kimi-k3-max` |
| GLM 5.1 | 0,05 credits per 100 input tokens 0,168 credits per 100 output tokens | `glm-5.1` |
| DeepSeek v4 Pro | 0,083 credits per 100 input tokens 0,195 credits per 100 output tokens | `deepseek-v4-pro` |
| DeepsSeek v4 Flash | 0,006 credits per 100 input tokens 0,013 credits per 100 output tokens | `deepseek-v4-flash` |
| Minimax M2.5 | 0.015 credits per 100 input tokens 0.053 credits per 100 output tokens | `minimax-m2.5` |
| ChatGPT 5.4 Mini | 0,042 credits per 100 input tokens 0,252 credits per 100 output tokens | `gpt-5.4-mini` |
| ChatGPT 5.4 Mini High | 0,042 credits per 100 input tokens 0,252 credits per 100 output tokens | `gpt-5.4-mini-high` |
| ChatGPT 5.4 Mini Medium | 0,036 credits per 100 input tokens 0,216 credits per 100 output tokens | `gpt-5.4-mini-medium` |
| ChatGPT 5.4 Mini Low | 0,042 credits per 100 input tokens 0,252 credits per 100 output tokens | `gpt-5.4-mini-low` |
| ChatGPT 5.4 Nano | 0,011 credits per 100 input tokens 0,070 credits per 100 output tokens | `gpt-5.4-nano` |
| ChatGPT 5.4 Nano High | 0,011 credits per 100 input tokens 0,070 credits per 100 output tokens | `gpt-5.4-nano-high` |
| ChatGPT 5.4 Nano Medium | 0,009 credits per 100 input tokens 0,060 credits per 100 output tokens | `gpt-5.4-nano-medium` |
| ChatGPT 5.4 Nano Low | 0,011 credits per 100 input tokens 0,070 credits per 100 output tokens | `gpt-5.4-nano-low` |
| ChatGPT 5.4 | 0,140 credits per 100 input tokens 0,840 credits per 100 output tokens | `gpt-5.4` |
| ChatGPT 5.4 Thinking | 0,140 credits per 100 input tokens 0,840 credits per 100 output tokens | `gpt-5.4-thinking` |
| ChatGPT 5.3 Latest | 0,084 credits per 100 input tokens 0,672 credits per 100 output tokens | `gpt-5.3-chat-latest` |
| ChatGPT 5.3-Codex | 0,084 credits per 100 input tokens 0,672 credits per 100 output tokens | `gpt-5.3-codex` |
| ChatGPT 5.2 Latest | 0,084 credits per 100 input tokens 0,672 credits per 100 output tokens | `gpt-5.2-chat-latest` |
| ChatGPT 5.2 | 0,098 credits per 100 input tokens 0,784 credits per 100 output tokens | `gpt-5.2` |
| ChatGPT 5.1 | 0,075 credits per 100 input tokens 0,60 credits per 100 output tokens | `gpt-5.1` |
| ChatGPT 5 | 0,05 credits per 100 input tokens 0,40 credits per 100 output tokens | `gpt-5` |
| ChatGPT 5 Latest | 0,05 credits per 100 input tokens 0,40 credits per 100 output tokens | `gpt-5-latest` |
| ChatGPT 5 Mini | 0,010 credits per 100 input tokens 0,080 credits per 100 output tokens | `gpt-5-mini` |
| ChatGPT 5 Nano | 0,002 credits per 100 input tokens 0,016 credits per 100 output tokens | `gpt-5-nano` |
| ChatGPT 4o Mini | 0,007 credits per 100 input tokens 0,029 credits per 100 output tokens | `gpt-4o-mini` |
| ChatGPT 4.1 Nano | 0,005 credits per 100 input tokens 0,019 credits per 100 output tokens | `gpt-4.1-nano` |
| ChatGPT 4.1 Mini | 0,019 credits per 100 input tokens 0,077 credits per 100 output tokens | `gpt-4.1-mini` |
| ChatGPT 4.1 | 0,096 credits per 100 input tokens 0,384 credits per 100 output tokens | `gpt-4.1` |
| o4 Mini | 0,053 credits per 100 input tokens 0,211 credits per 100 output tokens | `gpt-o4-mini` |
| o4 Mini High | 0,053 credits per 100 input tokens 0,211 credits per 100 output tokens | `gpt-o4-mini-high` |
| o3 | 0,096 credits per 100 input tokens 0,384 credits per 100 output tokens | `gpt-o3` |
| o3 Mini | 0,052 credits per 100 input tokens 0,211 credits per 100 output tokens | `gpt-o3-mini` |
| o3 Mini High | 0,052 credits per 100 input tokens 0,211 credits per 100 output tokens | `gpt-o3-mini-high` |
| o1 | 0,720 credits per 100 input tokens 2,88 credits per 100 output tokens | `gpt-o1` |
| ChatGPT 4o | 0,120 credits per 100 input tokens 0,480 credits per 100 output tokens | `gpt-4o` |
| ChatGPT oss 20B | 0,002 credits per 100 input tokens 0,009 credits per 100 output tokens | `gpt-oss-20b` |
| ChatGPT oss 120B | 0,005 credits per 100 input tokens 0,027 credits per 100 output tokens | `gpt-oss-120b` |
| GLM 5 | 0,045 credits per 100 input tokens 0,143 credits per 100 output tokens | `glm-5` |
| GLM 4.7 | 0,022 credits per 100 input tokens 0,106 credits per 100 output tokens | `glm-4.7` |
| GLM 4.7 Flash | 0,003 credits per 100 input tokens 0,022 credits per 100 output tokens | `glm-4.7-flash` |
| DeepSeek R1 | 0,64 credits per 100 input tokens 0,64 credits per 100 output tokens | `deepseek-r1` |
| DeepSeek R1 Small | 0,011 credits per 100 input tokens 0,033 credits per 100 output tokens | `deepseek-r1-small` |
| DeepSeek V3.2 | 0.013 credits per 100 input tokens 0.019 credits per 100 output tokens | `deepseek-v3.2` |
| DeepSeek V3.1 | 0.024 credits per 100 input tokens 0.0534 credits per 100 output tokens | `deepseek-v3-0324` |
| Kimi K2.5 | 0.028 credits per 100 input tokens 0.157 credits per 100 output tokens | `kimi-k2.5` |
| Kimi K2 | 0.024 credits per 100 input tokens 0.096 credits per 100 output tokens | `kimi-k2` |
| Qwen 3 Max | 0.058 credits per 100 input tokens 0.288 credits per 100 output tokens | `qwen-3-max` |
| Qwen 3 Coder | 0,024 credits per 100 input tokens 0,096 credits per 100 output tokens | `qwen-3-coder-235b` |
| Qwen 3 | 0,008 credits per 100 input tokens 0,036 credits per 100 output tokens | `qwen-3-235b` |
| Gemini 2.5 Flash | 0,014 credits per 100 input tokens 0,12 credits per 100 output tokens | `gemini-2.5-flash` |
| Gemini 2.0 Flash | 0,007 credits per 100 input tokens 0,028 credits per 100 output tokens | `gemini-2.0-flash` |
| Gemini 2.0 Flash Lite | 0,003 credits per 100 input tokens 0,014 credits per 100 output tokens | `gemini-2.0-flash-lite` |
| Gemini 2.5 Pro | 0,12 credits per 100 input tokens 0,72 credits per 100 output tokens | `gemini-2.5-pro` |
| Claude 4.5 Haiku Thinking | 0,048 credits per 100 input tokens 0,24 credits per 100 output tokens | `claude-4.5-haiku-thinking` |
| Claude 4.7 Opus Thinking | 0,28 credits per 100 input tokens 1,40 credits per 100 output tokens | `claude-4.7-opus-thinking` |
| Claude 4.6 Opus Thinking | 0,28 credits per 100 input tokens 1,4 credits per 100 output tokens | `claude-4.6-opus-thinking` |
| Claude 4.6 Opus | 0,28 credits per 100 input tokens 1,4 credits per 100 output tokens | `claude-4.6-opus` |
| Claude 4.5 Opus Thinking | 0,28 credits per 100 input tokens 1,4 credits per 100 output tokens | `claude-4.5-opus-thinking` |
| Claude 4.5 Opus | 0,28 credits per 100 input tokens 1,4 credits per 100 output tokens | `claude-4.5-opus` |
| Claude 4.1 Opus | 0,72 credits per 100 input tokens 3,6 credits per 100 output tokens | `claude-4.1-opus` |
| Claude 4.1 Opus Thinking | 0,72 credits per 100 input tokens 3,6 credits per 100 output tokens | `claude-4.1-opus-thinking` |
| Claude 4.6 Sonnet Thinking | 0,168 credits per 100 input tokens 0,84 credits per 100 output tokens | `claude-4.6-sonnet-thinking` |
| Claude 4.6 Sonnet | 0,168 credits per 100 input tokens 0,84 credits per 100 output tokens | `claude-4.6-sonnet` |
| Claude 4.6 Sonnet Thinking | 0,17 credits per 100 input tokens 0,84 credits per 100 output tokens | `claude-4.6-sonnet-thinking` |
| Claude 4 Sonnet | 0,144 credits per 100 input tokens 0,72 credits per 100 output tokens | `claude-4-sonnet` |
| Claude 4 Sonnet Thinking | 0,144 credits per 100 input tokens 0,72 credits per 100 output tokens | `claude-4-sonnet-thinking` |
| Claude 4 Opus | 0,72 credits per 100 input tokens 3,6 credits per 100 output tokens | `claude-4-opus` |
| Claude 4 Opus Thinking | 0,72 credits per 100 input tokens 3,6 credits per 100 output tokens | `claude-4-opus-thinking` |
| Llama 4 Maverick | 0.010 credits per 100 input tokens 0.029 credits per 100 output tokens | `meta-llama-4-maverick` |
| Llama 4 Scout | 0.005 credits per 100 input tokens 0.016 credits per 100 output tokens | `meta-llama-4-scout` |
| Llama 3.3 70B | 0.011 credits per 100 input tokens 0.019 credits per 100 output tokens | `meta-llama-3.3-70b-instruct` |
| Llama 3.2 11B | 0.002 credits per 100 input tokens 0.002 credits per 100 output tokens | `llama-3.2-11b-vision-preview` |
| Llama 3.2 90B | 0.017 credits per 100 input tokens 0.019 credits per 100 output tokens | `llama-3.2-90b-vision-preview` |
| Llama 3.1 405b | 0.456 credits per 100 input tokens 0.456 credits per 100 output tokens | `meta-llama-3.1-405b-instruct` |
| Llama 3.1 8b | 0.002 credits per 100 input tokens 0.004 credits per 100 output tokens | `meta-llama-3-1-8b-instruct` |
| Llama 3 70b | 0.031 credits per 100 input tokens 0.132 credits per 100 output tokens | `meta-llama-3-70b-instruct` |
| Command A | 0,2 credits per 100 input tokens 0,8 credits per 100 output tokens | `cohere-command-a` |
| Command R7B | 0,002 credits per 100 input tokens 0,007 credits per 100 output tokens | `cohere-command-r7b` |
| Command R | 0,024 credits per 100 input tokens 0,072 credits per 100 output tokens | `cohere-command-r` |
| Command RPus | 0,12 credits per 100 input tokens 0,60 credits per 100 output tokens | `cohere-command-r-plus` |
| ChatGPT 3.5 Turbo | 0,04 credits per 100 input tokens 0,12 credits per 100 output tokens | `gpt-3.5-turbo` |
| ChatGPT 4 Turbo | 0,8 credits per 100 input tokens 2,4 credits per 100 output tokens | `gpt-4-turbo` |
| Tess 6.1 | 0.056 credits per 100 input tokens 0.280 credits per 100 output tokens | `tess-6.1` |
| Tess 5 | 0.120 credits per 100 input tokens 0.720 credits per 100 output tokens | `tess-v5` |
| Tess 5 PRO | 0.720 credits per 100 input tokens 3.600 credits per 100 output tokens | `tess-5-pro` |
| Tess AI Light | 0.007 credits per 100 input tokens 0.029 credits per 100 output tokens | `tess-ai-light` |
| Tess AI v3 | 0.750 credits per 100 input tokens 1.750 credits per 100 output tokens | `tess-ai-v3` |
| Claude 3 Haiku | 0,012 credits per 100 input tokens 0,060 credits per 100 output tokens | `claude-3-haiku-20240307` |
| Llama 2 13b | 0.005 credits per 100 input tokens 0.024 credits per 100 output tokens | `llama-2-13b-chat` |
| Llama 2 70b | 0.031 credits per 100 input tokens 0.132 credits per 100 output tokens | `llama-2-70b-chat` |
## Image Models
| Model | Cost | API Slug |
| ------------------------------------------ | ----------------------------- | -------------------------------------------- |
| TESS 6 | Starting at 59,4 credits | `tess-6` |
| (API) Nano Banana 2 | Starting at 21,6 credits | `(api)-nano-banana-2` |
| (API) Nano Banana Pro | Starting at 78,4 credits | `(api)-nano-banana-pro` |
| (GPT) Image 2 | Starting at 97,99 credits | `(api)-gpt-image-2` |
| (API) Seedream 4.5 | Starting at 19,2 credits | `(api)-seedream-4.5` |
| (API) Grok Imagine Image | Starting at 11,2 credits | `(api)-grok-imagine-image` |
| (API) GPT Image 1.5 | Starting at 6,45 credits | `(api)-gpt-image-1.5` |
| (API) GPT Image 1 | Starting at 4,84 credits | `(api)-gpt-image-1` |
| (API) Reve Create | Starting at 12 credits | `(api)-reve-create` |
| (API) Reve Edit | Starting at 19,2 credits | `(api)-reve-edit` |
| (API) Reve Edit Fast | Starting at 4,8 credits | `(api)-reve-edit-fast` |
| (API) Reve Remix | Starting at 19,2 credits | `(api)-reve-remix` |
| (API) Recraft Vectorize | Starting at 4,8 credits | `(api)-recraft-vectorize` |
| (API) Bria AI Image 3.2 | Starting at 19,2 credits | `(api)-bria-ai-image-3.2` |
| (API) Runway Gen-4 Turbo | Starting at 48 credits | `(api)-runway-gen-4-turbo` |
| (API) Qwen Image | Starting at 12 credits | `(api)-qwen-image` |
| (API) Seedream 4 | Starting at 14,4 credits | `(api)-seedream-4` |
| (API) Dreamina 3.1 | Starting at 18 credits | `(api)-dreamina-3.1` |
| (API) Seededit 3 | Starting at 14,4 credits | `(api)-seededit-3` |
| (API) Seedream 3 | Starting at 14,4 credits | `(api)-seedream-3` |
| (API) Leonardo AI Phoenix | Starting at 40,32 credits | `(api)-leonardo-ai-phoenix` |
| (API) Leonardo AI Flux | Starting at 12,96 credits | `(api)-leonardo-ai-flux` |
| (API) Leonardo AI PhotoReal | Starting at 37,44 credits | `(api)-leonardo-ai-photoreal` |
| (API) Leonardo AI Inpaint | Starting at 8,64 credits | `(api)-leonardo-ai-inpaint` |
| (API) Leonardo AI Upscaler | Starting at 48,96 credits | `(api)-leonardo-ai-upscaler` |
| (API) Nano Banana | Starting at 18,576 credits | `(api)-nano-banana` |
| (API) Google Imagen 4 | Starting at 19,2 credits | `(api)-google-imagen-4` |
| (API) Google Imagen 4 Ultra | Starting at 19,2 credits | `(api)-google-imagen-4-ultra` |
| (API) Google Imagen 3 Fast | Starting at 8 credits | `(api)-google-imagen-3-fast` |
| (API) Google Imagen 3 | Starting at 19,2 credits | `(api)-google-imagen-3` |
| (API) Flux 2 Pro | Starting at 3,6 credits | `(api)-flux-2-pro` |
| (API) Flux 2 Flex | Starting at 28,8 credits | `(api)-flux-2-flex` |
| (API) Flux 2 Dev | Starting at 23,04 credits | `(api)-flux-2-dev` |
| (API) Flux Kontext Pro | Starting at 19,2 credits | `(api)-flux-kontext-pro` |
| (API) Flux Kontext Max | Starting at 38,4 credits | `(api)-flux-kontext-max` |
| (API) Flux 1.1 Pro Ultra | Starting at 28,8 credits | `(api)-flux-1.1-pro-ultra` |
| (API) Flux 1.1 Pro | Starting at 19,2 credits | `(api)-flux-1.1-pro` |
| (API) Flux Pro | Starting at 26,4 credits | `(api)-flux-pro` |
| (API) Flux Schnell | Starting at 1,44 credits | `(api)-flux-schnell` |
| (API) Flux Dev | Starting at 14,4 credits | `(api)-flux-dev` |
| (API) Flux Fill Pro | Starting at 24 credits | `(api)-flux-fill-pro` |
| (API) Flux Fill Dev | Starting at 19,2 credits | `(api)-flux-fill-dev` |
| (API) Flux Redux Schnell | Starting at 1,44 credits | `(api)-flux-redux-schnell` |
| (API) Flux Redux Dev | Starting at 12 credits | `(api)-flux-redux-dev` |
| (API) Flux Depth Pro | Starting at 24 credits | `(api)-flux-depth-pro` |
| (API) Flux Depth Dev | Starting at 12 credits | `(api)-flux-depth-dev` |
| (API) Flux Canny Pro | Starting at 24 credits | `(api)-flux-canny-pro` |
| (API) Flux Canny Dev | Starting at 12 credits | `(api)-flux-canny-dev` |
| (API) Flux Schnell Lora | Starting at 9,6 credits | `(api)-flux-schnell-lora` |
| (API) Flux Dev Lora | Starting at 15,36 credits | `(api)-flux-dev-lora` |
| (API) Luma Photon | Starting at 4,077 credits | `(api)-luma-photon` |
| (API) Luma Photon Flash | Starting at 1,053 credits | `(api)-luma-photon-flash` |
| (API) MiniMax Image 01 | Starting at 4,8 credits | `(api)-minimax-image-01` |
| (API) Stable Diffusion 3.5 | Starting at 31,2 credits | `(api)-stable-diffusion-3.5` |
| (API) Stable Diffusion 3.5 Turbo | Starting at 19,2 credits | `(api)-stable-diffusion-3.5-turbo` |
| (API) Stable Diffusion 3 | Starting at 16,8 credits | `(api)-stable-diffusion-3` |
| (API) Stable Diffusion 3 Turbo | Starting at 19,2 credits | `(api)-stable-diffusion-3-turbo` |
| (API) Stable Diffusion 3 Medium | Starting at 16,8 credits | `(api)-stable-diffusion-3-medium` |
| (API) Stable Diffusion 2 | Starting at 1,824 credits | `(api)-stable-diffusion-2` |
| (API) Ideogram 3.0 | Starting at 14,4 credits | `(api)-ideogram-3.0` |
| (API) Ideogram 2a | Starting at 19,2 credits | `(api)-ideogram-2a` |
| (API) Ideogram 2a Turbo | Starting at 12 credits | `(api)-ideogram-2a-turbo` |
| (API) Ideogram 2.0 | Starting at 38,4 credits | `(api)-ideogram-2.0` |
| (API) Ideogram 2.0 Turbo | Starting at 24 credits | `(api)-ideogram-2.0-turbo` |
| (API) Recraft v3 | Starting at 19,2 credits | `(api)-recraft-v3` |
| (API) Recraft 20b | Starting at 10,56 credits | `(api)-recraft-v20b` |
| (API) DALL-E 3 | Starting at 38,4 credits | `(api)-dall-e-3` |
| (API) DALL-E 2 | Starting at 8,64 credits | `(api)-dall-e-2` |
| (API) Microsoft Bing for Icons | Starting at 6,72 credits | `(api)-microsoft-bing-for-icons` |
| Tess AI v4 | Starting at 7,2 credits | `tess-ai-v4` |
| Tess AI v3 | Starting at 40,000032 credits | `tess-ai-v3` |
| Tess AI v2 | Starting at 47,328 credits | `tess-ai-v2` |
| Tess AI v1 | Starting at 3,36 credits | `tess-ai-v1` |
| AI Dream (Light Version) | Starting at 11,52 credits | `ai-dream-(light-version)` |
| Anime Dream | Starting at 8,16 credits | `anime-dream` |
| Architecture Dream | Starting at 4,368 credits | `architecture-dream` |
| Doodle Dream | Starting at 23,04 credits | `doodle-dream` |
| Ecommerce Dream | Starting at 9,12 credits | `ecommerce-dream` |
| Emoji Dream | Starting at 5,28 credits | `emoji-dream` |
| Fantasy Dream | Starting at 36 credits | `fantasy-dream` |
| Fantasy Dream (Light) | Starting at 36,96 credits | `fantasy-dream-(light)` |
| Icon Dream | Starting at 7,2 credits | `icon-dream` |
| Logo Dream | Starting at 7,2 credits | `logo-dream` |
| Pixar Dream | Starting at 6,72 credits | `pixar-dream` |
| Pose Dream | Starting at 14,4 credits | `pose-dream` |
| QR Code Dream | Starting at 7,68 credits | `qr-code-dream` |
| Realistc Dream v1 | Starting at 8 credits | `realistc-dream-v1` |
| Realistic Dream v2 (New Model) | Starting at 96 credits | `realistic-dream-v2-(new-model)` |
| RPG Dream | Starting at 12,8 credits | `rpg-dream` |
| Sketch Dream | Starting at 3,312 credits | `sketch-dream` |
| T-shirt Dream | Starting at 91,2 credits | `t-shirt-dream` |
| Tatoo Dream | Starting at 6,264 credits | `tatoo-dream` |
| (Magic Dream) Background Remover | Starting at 0,3216 credits | `(magic-dream)-background-remover` |
| (Magic Dream) Background Remover v2 | Starting at 9,6 credits | `(magic-dream)-background-remover-v2` |
| (Magic Dream) Blend Images | Starting at 48 credits | `(magic-dream)-blend-images` |
| (Magic Dream) Blur Remover | Starting at 38,4 credits | `(magic-dream)-blur-remover` |
| (Magic Dream) Background Color and Shadows | Starting at 48 credits | `(magic-dream)-background-color-and-shadows` |
| (Magic Dream) Clothes Mask | Starting at 14,88 credits | `(magic-dream)-clothes-mask` |
| (Magic Dream) Inverted Clothes Mask | Starting at 14,88 credits | `(magic-dream)-inverted-clothes-mask` |
| (Magic Dream) Face Mask | Starting at 14,88 credits | `(magic-dream)-face-mask` |
| (Magic Dream) Erase Objects | Starting at 14,4 credits | `(magic-dream)-erase-objects` |
| (Magic Dream) Faceswap | Starting at 20,64 credits | `(magic-dream)-faceswap` |
| (Magic Dream) Image UpScale | Starting at 0,48 credits | `(magic-dream)-image-upscale` |
| (Magic Dream) InPaint v1 | Starting at 2,304 credits | `(magic-dream)-inpaint-v1` |
| (Magic Dream) InPaint v2 | Starting at 14,4 credits | `(magic-dream)-inpaint-v2` |
| (Magic Dream) Mask Generator | Starting at 13,44 credits | `(magic-dream)-mask-generator` |
| (Magic Dream) Outpaint | Starting at 19,2 credits | `(magic-dream)-outpaint` |
| (Magic Dream) Repair Facial Anomalies | Starting at 1,632 credits | `(magic-dream)-repair-facial-anomalies` |
| (Magic Dream) Search & Replace | Starting at 19,2 credits | `(magic-dream)-search-&-replace` |
| (Magic Dream) Virtual Dressing | Starting at 52,8 credits | `(magic-dream)-virtual-dressing` |
| (Magic Dream) Upscale with Mask | Starting at 7,68 credits | `(magic-dream)-upscale-with-mask` |
| (Magic Dream) Mask with a Prompt | Starting at 6,72 credits | `(magic-dream)-mask-with-a-prompt` |
| (Prompthero) OpenJourney | Starting at 2,592 credits | `(api)-openjourney` |
## Video Models
| Model | Cost | API Slug |
| -------------------------------------- | -------------------------- | ---------------------------------------- |
| TESS 6 | Starting at 594 credits | `tess-6` |
| (API) Kling AI 3.0 | Starting at 284,24 credits | `(api)-kling-ai-3.0` |
| (API) Kling AI 3.0 Omni | Starting at 241,92 credits | `(api)-kling-ai-3.0-omni` |
| (API) Veo 3.1 | Starting at 896 credits | `veo-3.1` |
| (API) Veo 3.1 Lite | Starting at 96 credits | `veo-3.1-lite` |
| (API) Seedance 2.0 | Starting at 38,4 credits | `(api)-seedance-2.0` |
| (API) Grok Imagine Video | Starting at 28 credits | `(api)-grok-imagine-video` |
| (API) Veo 3 | Starting at 896 credits | `veo-3` |
| (API) Veo 3 Fast | Starting at 384 credits | `veo-3` |
| (API) Veo 2 | Starting at 1200 credits | `veo-2` |
| Sora 2 | Starting at 192 credits | `sora-2` |
| Sora 2 Pro | Starting at 576 credits | `sora-2-pro` |
| (API) Runway Gen-4 Turbo | Starting at 120 credits | `(api)-runway-gen-4-turbo` |
| (API) Runway Gen-3 Alpha Turbo | Starting at 120 credits | `(api)-runway-gen-3-alpha-turbo` |
| (API) Kling AI 2.5 Turbo Pro | Starting at 168 credits | `(api)-kling-ai-2.5-turbo-pro` |
| (API) Kling AI 2.1 Master | Starting at 672 credits | `(api)-kling-ai-2.1-master` |
| (API) Kling AI 2.1 | Starting at 120 credits | `(api)-kling-ai-2.1` |
| (API) Kling AI 1.6 Standard | Starting at 150 credits | `(api)-kling-ai-1.6-standard` |
| (API) Kling AI 1.6 Pro | Starting at 228 credits | `(api)-kling-ai-1.6-pro` |
| (API) Luma Labs Ray 2.0 | Starting at 108 credits | `(api)-luma-labs-ray-2.0` |
| (API) Luma Labs Ray 2.0 Flash | Starting at 37,8 credits | `(api)-luma-labs-ray-2.0-flash` |
| (API) Luma Labs Ray 1.6 | Starting at 210 credits | `(api)-luma-labs-ray-1.6` |
| (API) Seedance 1.5 Pro | Starting at 29,12 credits | `(api)-seedance-1.5-pro` |
| (API) Seedance 1 Pro | Starting at 72 credits | `(api)-seedance-1-pro` |
| (API) Seedance 1 Lite | Starting at 43,2 credits | `(api)-seedance-1-lite` |
| (API) MiniMax - Hailou 02 | Starting at 48,09 credits | `(api)-minimax---hailou-02` |
| (API) MiniMax - Hailuo I2V-01 | Starting at 240 credits | `(api)-minimax---hailuo-i2v-01` |
| (API) MiniMax - Hailuo I2V-01-Live | Starting at 240 credits | `(api)-minimax---hailuo-i2v-01-live` |
| (API) MiniMax - Hailuo I2V-01-Director | Starting at 240 credits | `(api)-minimax---hailuo-i2v-01-director` |
| (API) Wan 2.5 Fast | Starting at 163,2 credits | `(api)-wan-2.5-fast` |
| (API) Wan 2.5 | Starting at 120 credits | `(api)-wan-2.5` |
| (API) Wan 2.2 Animate Replace | Starting at 21,6 credits | `(api)-wan-2.2-animate-replace` |
| (API) Wan 2.2 Animate Animation | Starting at 21,6 credits | `(api)-wan-2.2-animate-animation` |
| (API) Wan 2.2 | Starting at 192 credits | `(api)-wan-2.2` |
| (API) Wan 2.2 Fast | Starting at 24 credits | `(api)-wan-2.2-fast` |
| (API) Wan 2.1 | Starting at 216 credits | `(api)-wan-2.1` |
| (API) Leonardo AI Motion | Starting at 64,8 credits | `(api)-leonardo-ai-motion` |
| Tess AI v3 | Starting at 276 credits | `tess-ai-v3` |
| One-Second Animation Dream | Starting at 62,4 credits | `one-second-animation-dream` |
| (Magic Dream) Sounds to Video | Starting at 7,68 credits | `(magic-dream)-sound-to-video` |
| (Magic Dream) B\\\&W Mask Generator | Starting at 24,48 credits | `(magic-dream)-b&w-mask-generator` |
| (Magic Dream) Chroma Key Background | Starting at 24,48 credits | `(magic-dream)-chroma-key-background` |
| (Magic Dream) Animate Image v1 | Starting at 187,2 credits | `(magic-dream)-animate-image-v1` |
| (Magic Dream) Animate Image v2 | Starting at 110,4 credits | `(magic-dream)-animate-image-v2` |
| (Magic Dream) Video Upscale | Starting at 115,2 credits | `video_upscale` |
| (Magic Dream) Colorize Old Videos | Starting at 41,28 credits | `(magic-dream)-colorize-old-videos` |
| (Magic Dream) Cartoonize Video Effect | Starting at 15,36 credits | `(magic-dream)-cartoonize-video-effect` |
| Tess AI v4 | Starting at 120 credits | `tess-ai-v4` |
### **Video Editing Models**
| Model | Cost | API Slug |
| ----------------------- | ---------------------------- | ------------------------- |
| Runway Aleph | Up to 75 credits / second | `runway_aleph` |
| Chroma Key Background | 34 credits / video | `chroma_key_background` |
| Video Upscale | Up to 10 credits / second | `video_upscale` |
| Film Maker | Up to 10 credits / execution | `film_maker` |
| Sound to Video | Up to 10 credits / execution | `sound_to_video` |
| Extract Last Frame | Up to 10 credits / execution | `extract_last_frame` |
| Wan Animate | 22.7 credits / video | `wan_animate` |
| Kling AI Motion Control | Starting at 33,6 credits | `kling_ai_motion_control` |
### **Avatar Models**
| Model | Cost | API Slug |
| ----------- | --------------------- | ------------- |
| Heygen | 5 credits / second | `heygen` |
| Wan Animate | 9.43 credits / second | `wan_animate` |
| Omni Human | 75.5 credits / second | `omni_human` |
### **Music Models**
| Model | Cost | API Slug |
| ---------------- | --------------------- | ------------------ |
| Minimax Music | 16 credits / music | `minimax_music` |
| Google Lyria | 0.81 credits / second | `google_lyria` |
| Stability Music | 101 credits / music | `stability_music` |
| ElevenLabs Music | 5.89 credits / second | `elevenlabs_music` |
### Notes
* Values may vary depending on the selected configuration
* We always display the **lowest possible cost of the model**
* Models with multiple variables consider the cheapest option
### **Average credit usage for attachments in chat**
* TXT - 20 credits
* PDF - 1.68 credits / page
* Excel - 1 credit
* Sheets - 20 credits
* CSV - 1 credit
* Docx - 20 credits
* PPT - 1 credit
* Webscraper - 1 credit
* Image - 0 credits
* Audio - Variable depending on the model used
From August 18 through September 1, 2026, each processed PDF page will cost only **1 credit** — about 40% off the standard 1.68 credits per page. Regular and OCR PDFs use the same per-page rate.
PDF uploads are limited to **50 MB per file**. Other supported chat formats still allow **200 MB per file**.
If you have any questions, feel free to contact our support via email: [**support@tess.im**](mailto:support@tess.im)
# Music
Source: https://docs.tess.im/en/music
Tess AI’s Music tool lets you create original songs from natural-language prompts. You describe genre, instruments, mood, structure, and duration — and the AI generates a track ready to use in videos, presentations, podcasts, bumpers, music prototypes, and social media content.
**What is the Music Generator**
It’s a “music studio” inside the chat:
* you describe what you want to hear
* you choose (when available) the music generation model
* you generate an original track
* you refine with new instructions until you reach the ideal result
You don’t need to know music theory, play an instrument, or use production software. The final quality depends mainly on how clear your prompt is.
### **Available models**
Tess AI may offer different music generation models, for example:
* Minimax Music
* Google Lyria
* Stability Music
* ElevenLabs Music
Each model tends to have a different “signature” (timbre, style, vocals, arrangement density, prompt responsiveness). To find the best sound for a project, it’s worth testing the same prompt in 2 models and comparing.
### **Use cases**
* Custom background tracks for videos and lives
* Bumpers and jingles (brand, product, campaign)
* Music for institutional presentations
* Prototypes of musical ideas (melody, groove, mood)
* Content for social media (short loops, specific moods)
### **How to use the tool**
Enable it in Tess Chat, choose one of the models, and write a prompt (simple model).
Use this formula:
*Genre + Instruments + Mood + Tempo/BPM + Duration + Structure references*
Examples:
* “Create a soft jazz instrumental with piano, bass, and drums, melancholic, 90 BPM, 60 seconds.”
* “Minimalist electronic track, synths and dry kick, futuristic atmosphere, 120 BPM, 30 seconds, with a short intro and a light drop.”
Once you get the result, keep asking for specific adjustments, for example:
* Structure: “Make a 5s intro, then a catchy chorus, and end with a fade-out.”
* Energy: “Make the chorus more energetic and the verse calmer.”
* Instrumentation: “Remove the sax and add clean guitar with reverb.”
* Mix: “Lower the drums and bring up the bass.”
* Harmony: “In C major” or “more tense, with minor chords.”
**Tips for better prompts**
* Be specific about the goal: “background music for a corporate video” vs “music for a party”
* Set duration and BPM (even if approximate)
* Say whether you want instrumental or vocals
* Indicate mood with concrete adjectives: “intimate, soft, cinematic, tense, triumphant”
* For social media, ask for a “loop” and an “ending that connects back to the beginning”
### **Prompt Examples for Music**
* Corporate “Modern corporate instrumental track, light piano and pads, inspiring and discreet, 100 BPM, 45 seconds, no vocals, ending with fade-out.”
* Podcast “Soft lo-fi ambient, light drums with hi-hats, smooth bass, welcoming mood, 80 BPM, 60 seconds, continuous loop, no attention-grabbing melodies.”
* Short bumper “8-second bumper, electronic pop, catchy hook, 128 BPM, ending with a short impact, no vocals.”
**Credits and usage**
Music generation usually consumes more credits than text responses, because it involves audio processing. To optimize, test first with 10–20 seconds and refine the prompt before generating long versions.
Take the opportunity to generate the audio you need, royalty-free, for your campaigns, projects, or other communications.
# Notion
Source: https://docs.tess.im/en/notion
Connect Notion to Tess to find pages, databases, and knowledge from chat and agents.
The **Notion** connector integrates Tess with Notion. Once connected, the AI can search pages and databases, summarize knowledge, and support documentation workflows inside chats and agents.
Notion is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Notion account with access to the pages/databases you need.
* Permission to authorize the Notion integration for those workspaces.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Notion** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Notion** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search pages and databases** across shared Notion content
* **Summarize docs and wikis** into actionable briefs
* **Create or update pages** when write access is available
* **Support knowledge routines** for product, ops, and support teams
* **Keep internal documentation usable inside Tess**
## Example prompts
> 1. Find the onboarding runbook in Notion and summarize the first-week checklist.
> 2. What changed recently in the Product Specs database?
> 3. Create a meeting notes page for today's sync with action items.
> 4. Pull the FAQs about billing and rewrite them as a short internal brief.
## Best practices
* Share page/database names that are distinctive.
* Ask before creating pages in shared spaces.
* In agents, define whether Notion is for retrieval, summarization, or writing.
## Troubleshooting
In Notion, confirm the integration was granted access to the relevant pages/databases.
Reconnect Notion in Connectors and re-select the pages the integration can access.
The connected account or integration share may be read-only.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Outlook
Source: https://docs.tess.im/en/outlook
Connect Outlook to Tess to work with email and calendar context from Microsoft accounts in chat and agents.
The **Outlook** connector integrates Tess with Microsoft Outlook. Once connected, the AI can help with mailbox and calendar tasks inside chats and agents, using the permissions of the connected Microsoft account.
Outlook is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Microsoft account with Outlook mail/calendar access.
* Permission to authorize the Outlook/Microsoft OAuth app.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Outlook** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Outlook** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search and summarize emails** from the connected mailbox
* **Draft and send messages** when send permissions are available
* **Check calendar availability** and upcoming events
* **Support inbox triage** with priorities and suggested replies
* **Keep Microsoft productivity work inside Tess**
## Example prompts
> 1. Find unread emails from Contoso about renewal and summarize next steps.
> 2. What does my Outlook calendar look like tomorrow morning?
> 3. Draft a reply to the latest email from Ana about the proposal and show it before sending.
> 4. List meetings this week that conflict with a 1-hour focus block.
## Best practices
* Say whether you mean mail, calendar, or both.
* Ask for a draft before sending external emails.
* In agents, define the Outlook role clearly (triage, scheduling, or both).
## Troubleshooting
Some Microsoft tenants require an admin to approve the app before users can connect.
Reconnect Outlook in Connectors after password, MFA, or policy changes.
Confirm the connected account can access that mailbox/calendar in Outlook.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Podcast
Source: https://docs.tess.im/en/podcast
The Podcast tool in Tess AI Chat will be your automated podcasting studio. It turns a script into a complete audio episode, with multiple voices, dialogues, and long duration — no microphone, no manual editing, and no audio software.
### **Where to find the Podcast Generator**
Inside Tess AI chat, just click the Tools button and choose the Podcast option:
This is a tool powered by advanced audio technology models. It reads your script and:
* interprets who the characters are
* assigns different voices
* generates a single cohesive audio file, simulating a podcast show with multiple participants
* It goes far beyond simple voiceover: it creates the feeling of a conversation, interview, debate, or roundtable.
### **Key advantages**
You’re not limited to a few seconds. It’s possible to create substantial episodes (like 10 minutes or more) in a single run.
In practice, there isn’t a strict limit on characters. You can create a host + co-host, interviewer + interviewee, a panel with multiple experts. All in a single script.
The Podcast Generator supports multiple languages, allowing you to produce episodes for different audiences or even mix segments in different languages (for example, questions in Portuguese and answers in English).
### **How to use it and create your podcast**
The flow is simple: just enable the tool and start making requests, choose the voice, send the script, and generate the episode.
All the complex work of editing, mixing, and assembling voices is handled by the AI. In the end, you receive a ready-to-download audio file that you can publish on podcast platforms, social media, or your website.
**Link to the generated Podcast:** [**Listen to the Podcast**](https://cdn.tess.im/assets/uploads/7b10767d-0096-4f72-8bd9-da747171ba98.mp3?_gl=1*1oowaa3*_gcl_au*MTY5NDY3MTc0MC4xNzY5NjkwMzQ2LjIwMDk3NDk3MjcuMTc3MDk5MDY5Ni4xNzcwOTkxMDA3*_ga*MTc0NDAwNTQ4Ny4xNzY5NjkwMzQ1*_ga_K1Q8FJY3BS*czE3NzA5OTA2OTUkbzQ5JGcxJHQxNzcwOTkxMDA3JGo2MCRsMCRoMA..*_ga_9D17W435GL*czE3NzA5OTA2OTUkbzM4JGcxJHQxNzcwOTkxMDA3JGo2MCRsMCRoMA..)
**Tips:**
1. **Clearly identify who is speaking**
Use a script format—this helps the AI separate lines, alternate voices, and keep a conversational rhythm:
\[Host]: Welcome to another episode of our podcast!
\[AI Specialist]: Thanks for the invitation, it’s a pleasure to be here.
2. **Mark emotions and intonation**
Give simple acting directions:
\[Host, in an excited tone]: Today’s news is simply incredible!
\[Interviewee, in a low and reflective voice]: I had never thought of it that way… \[pause]
### **When to use the Podcast Generator vs. Voiceover (Speech)**
* you want to simulate a conversation or multiple participants
* you need long episodes with a show-like dynamic
* you want a “show” experience (segments, debates)
* it’s just one voice reading a text (class, announcement, article)
* you want a simple and direct audio, without a podcast format
* you need short clips with a single voiceover
Tess AI’s Podcast Generator removes the technical barrier to creating a complete audio show. You focus on ideas and scripts; Tess handles voices, performance, and assembly into a single file ready for publishing.
It’s podcasting in accelerated mode: fast, scalable, and accessible for anyone or any team that wants to turn knowledge into audio content.
# Quickstart
Source: https://docs.tess.im/en/quickstart
### Agent Mode
Getting started with Tess Agent Computer is straightforward. There's no complex setup, no special configuration — just describe what you need, and Tess takes it from there.
Simply open the Agent Computer, write a single prompt with your instructions, and let Tess handle the rest. It will plan the work, break it into steps, execute everything autonomously, and deliver the final result directly to you. That's it.
Naturally, the better your prompt, the better the agent's output. So try to describe what you want researched, the desired delivery format, the context in which the work will be used, and other key elements of a well-structured prompt.
### What can you do with Tess Agent Computer?
Here are some examples of what Tess Agent can handle for you across different types of work.
* Webpage building: structure an entire website with multiple pages using Tess Agent — simply describe the content and layout of each page and let it handle the rest.
* Dashboard creation: transform unstructured data into a clean, professional dashboard view — ready to present or share with your team.
* Spreadsheets with formulas: generate complete Excel files with working functions like VLOOKUP, conditional formatting, and multiple organized tabs — not just raw CSVs that still need editing.
* Presentations: turn rough notes or meeting transcripts into ready-to-use slide decks.
* Reports from scattered inputs: convert voice memos, bullet points, and disorganized notes into polished, well-structured documents.
* Research synthesis: combine information from web searches, articles, papers, and personal notes into structured reports or clear, cohesive summaries.
* Transcript analysis: extract themes, key points, and action items from meeting notes, interviews, or lecture recordings — no manual reading required.
* Personal knowledge synthesis: ask Tess to go through your notes, journals, or research files and surface patterns, connections, and insights you might have overlooked.
* Statistical analysis: run outlier detection, cross-tabulation, and time-series analysis directly on your data files.
* Data visualization: generate charts and visual representations from your data — ready to use or share.
* Data transformation: clean, restructure, and process datasets so they're ready for whatever comes next.
### Chat Mode
Chat Mode is the simplest way to interact with Tess. We offer a unified interface where you can collaboratively use text, image, video, audio, narration, avatar creation models, as well as a variety of professional tools.
Tess orchestrates all of this work for you, turning the use of multiple types of AI into an integrated, conversational, and frictionless experience.
### Starting a Conversation
To get started, simply type your command (prompt) in the text box. You can ask questions, ask the AI to perform tasks, request text creation, analyze data, and much more.
* **Clear Commands and Instructions**: The clearer and more detailed your request, the better the result. Instead of saying "create a text", try being more specific: "create a text for a LinkedIn post about the impact of artificial intelligence on the financial market, with a professional tone and a call-to-action for a webinar".
* **Tess Micro Playbooks**: Just below the chat box, you have several "ice breaker" options to help you think of use cases and generate the corresponding prompts. All of these themes are available to help you get started with quality — Presentations, Search and Files, Web Development, Videos, Voice and Music, Images, Create Agents.
### Choosing the AI Model
Tess offers the flexibility to choose the most suitable AI model for each task.
You can manually select a specific model (such as Claude 4.8 Opus or ChatGPT 5.5) at the bottom of the chat window, or work with Auto Mode.
In Auto Mode, Tess analyzes your request and automatically selects the model with the best balance between cost and performance for that specific task, optimizing the use of your credits.
### Activating Your Agents in Chat Mode
You can call a specific agent to respond in the conversation at any time by using "@" followed by the agent's name. For example: @MarketingAgent, create three slogan options for my new campaign. This option is not available for private agents.
### Adding a Knowledge Base
The Knowledge Base allows you to upload files (such as PDFs, DOCX, TXT, etc.) so that the chosen model can consult that information before responding. It means training the chat with greater accuracy.
Imagine asking the AI to create a summary of a report or to answer specific questions about your own product manual. Simply attach the file to the chat and make your request to ensure accurate and relevant answers.
When you add a knowledge base in the chat, only that conversation is trained. If you need to use that knowledge base regularly, create an agent and train it with the documentation. In that case, the agent will always activate the added knowledge base.
### Activating a Tool
Tools enhance the performance of models or agents. They are features that enable actions beyond text generation, such as accessing the internet or social media to search for up-to-date information, creating virtual machines for data analysis and financial calculations, or generating/editing files.
Next to the chat box, you will find a menu of available Tools. Before sending your request, you can activate the "Internet" tool, for example. That way, when you ask "What were the main technology news stories this week?", the AI will use the internet to formulate the most up-to-date response.
### Integrate connectors into your account
Connectors expand Tess's role within the workspace. Instead of just generating text or analyzing chat, the AI now interacts with connected external systems. In other words, it goes from assistant to task operator, and this is especially relevant for agents, where behavior can be structured to automatically use connectors within flows.
Open the + option, locate the connectors button, and click "Add connectors" to add new ones or "Manage connectors" to manage existing connections. Search for the applications you want to integrate and connect them to grant the necessary permissions.
# Scheduling
Source: https://docs.tess.im/en/scheduling
Schedules allow Tess to execute tasks in a scheduled and recurring way, at specific times.
You can ask, for example:
* “Search the internet for yesterday’s main news about AI and bring me a report every day at 9:00 a.m.”
* “At the beginning of every month, generate a PDF report on the company’s sales, broken down by channels, main metrics, etc.”
It’s a feature designed to make your life easier and take repetitive work out of your day. With Schedules, you can automate in Tess all the valuable tasks you’d like to perform frequently.
### **What Scheduling is**
Scheduling is Tess’s ability to run a task automatically, without you having to ask again.
You define:
**1. THE TASK**\
What must be done
**2. FREQUENCY**\
When it should run
**3. SETTINGS**\
Context/execution used
Scheduling is executed via an agent (that is, it’s especially powerful when combined with Agent Mode and Tools such as Internet, Manage Files, Deep Analysis, etc.).
### Why it matters
You turn repetitive tasks into automation, working on daily/weekly/monthly reports; monitoring topics and news; consolidating metrics; periodic checks.
Once scheduled, it always runs at the defined time.
For CS/Revenue/Marketing/Product teams, this enables use cases such as:
* recurring usage reports
* feedback summaries
* metric tracking
* smart alerts (when combined with data/integrations)
### **How Scheduling works**
Currently, scheduling runs using the chat settings and works with the settings from the first chat message as requested.
If you want to change settings, you can open the settings and go to Schedules to change instructions, frequency, etc.
Automation is tool-driven:
* With Internet: research and monitoring
* With Manage Files: generate/edit PDFs, documents, and presentations
* With Deep Analysis: recurring analysis on spreadsheets/CSV
* With Integrations: trigger external actions (with the proper security care)
**How to set up a schedule**
Choose the mode (Standard Chat or Agent Mode), the model (LLM), and the necessary tools (Internet, etc.). Leave the chat’s initial context “the right way”.
Include the objective, output format (bullet points, PDF, table, etc.), frequency and time (daily, weekly, monthly, every X minutes), sources and criteria (if it’s internet: topics, keywords, regions, language).
Tess records the schedule and starts executing it automatically.
**Best practices**
* Be specific about the output: Work, for example, like this: “I want a daily report with: 10 news items with link, 1 impact paragraph, 3 actionable insights, and 1 recommendation of what to monitor tomorrow.”
* Start simple and evolve: First schedule a simple report. Then you add: sections, filters, formats, attachments (PDF), integrations.
* Watch the cost: Recurring schedules can consume credits frequently. Recommendation: define a cadence that makes sense (daily/weekly) and only increase the frequency when there is a real need.
# Initial Setup
Source: https://docs.tess.im/en/setup
See how to configure your workspace in Tess.
The first step to making the most of Tess is to set up your workspace. The platform was designed for professional use, allowing you to centralize your work and collaborate with your team efficiently.
You can configure:
* Profile Name
* Profile and Cover Images
* Description and Biography
* Social Profiles
You can invite all members of your team to the platform. To do so, go to the settings and, in the member management area, send invitations to your team or create a secret link for bulk invitations!
Step by Step:
* Go to the Settings menu.
* Select the Members or Users tab.
* Click on Invite new member, set the permission level, and enter the professional's email address. Or generate a secret link so more people can log in at once.
Your workspace has a single credit wallet that is shared among all users. This simplifies management and ensures that the entire team has the resources needed to work, without the need to manage individual subscriptions.
The workspace administrator (Owner) can track consumption and add more credits whenever necessary.
Tip: assigning individual access to each team member not only organizes usage, but also increases the security and traceability of actions performed on the platform.
When you access Tess, you will find a clear and organized interface. Getting familiar with the main menus is essential for smooth navigation. Here are the main shortcuts on the platform's side menu:
* New Chat: Clicking this button opens a new chat with a clean context window to start working with the AI.
* Spaces: This is the ultimate control panel and repository for all files, artifacts, and items uploaded or generated within your workspace in Tess.
* Agent Studio: the environment where you can create and publish your AI Agents, fully no-code. In this section you can also access the Image, Video, Code, Audio, and Transcription Generators, if you want to use them separately (outside the chat interface).
* Latest Agents and Generators: To speed up your workflow, just below the Agent Studio button you will see the most recently used agents. With a single click, you can resume a task or start a new conversation with these agents, without having to search for them again in Agent Studio.
* Chats: folders created to group your conversations and make it easier to manage all your work. Just below, you will see your entire previous conversation history.
* Settings: Click on your username and access your account settings: manage your profile, workspace, members, and much more.
# Shareable Links
Source: https://docs.tess.im/en/shareable-links
Tess AI allows you to share chat conversations through links, which facilitates collaboration, internal alignment, and demonstrations. There are two sharing options, accessible through the sharing icon in the upper right corner of the chat: Clone Chat and Public Chat (Replay).
### **Where to find it?**
* Open the chat you want to share (it's important that it already has a history).
* In the upper right corner, click on the sharing icon
* Choose the type of link: Clone Chat or Public Chat (Replay)
### **Sharing options**
A link is generated that allows another person to open a copy of the chat and continue the conversation from where you left off. They will see all of your previous exchanges.
Use it when you want collaboration on projects and need to pass the context built so far to someone to continue from their own screen. Or if you have made an internal demonstration of a flow (e.g.: prompt, service structure, script) and the result can be reused by another user on Tess.
In short, the person can continue the chat and generate new messages based on the existing history without interfering with your screen or adapting it to their own context (without "reinventing" everything).
In this case, you will need to exclude the files from the knowledge base!
A public link is created that works as a "replay" of the conversation (showing the entire exchange in an animated way). Anyone with the link can view the interaction, even without a Tess AI account.
Use it to share a result with an external audience (e.g.: insight, tutorial, agent example), to show how Tess arrived at an output (process transparency), or even to send to a client/partner as a conversation reference (without giving editing access).
People will only be able to view the conversation (like a replay), so you do not need to log in to Tess to open the link, you do not need to exclude the files from the base.
In both ways it is possible to see the models used in each message, as well as the tools used during the conversation and also call some agent (resource @).
Warning
Be careful if the chat contains files with important data or sensitive information (personal data, keys, private links, internal details). Before generating the shareable link, delete all such files from the chat and prevent them from being exposed through the shared link. In these cases, consider: turning it into a text-based guide (without attachments) or making the material available through a separate secure channel.
### Relevant use case examples:
> 1. For Sales: it is a practical way to share real Tess use cases (with the execution and the result), without needing to record a video or redo the step-by-step process.
> 2. For Marketing: it is possible to share use cases in social media posts and take the audience directly to the experience, via link, in a quick and hands-on way.
# SharePoint
Source: https://docs.tess.im/en/sharepoint
The **SharePoint** connector integrates Tess with Microsoft's document management and intranet platform. Once connected, the AI can consult and work with your SharePoint content inside chats and agents, without switching tabs.
SharePoint is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth 2.0** authentication.
## Prerequisites
* Any user can connect SharePoint — you just need an account.
* You must have a **tenant** configured in SharePoint.
* You will need to provide the **Tenant Name** and, optionally, the **SharePoint Subsite**.
## How to connect
Before you begin, make sure your SharePoint administrator has already configured and validated the connector permissions. Tess only reflects the permissions defined in SharePoint — without that prior validation, the connection will not complete successfully.
**Tess will NEVER ask you for administrative permissions.** It only follows what was configured in SharePoint. If any screen requests administrative access on Tess's behalf and it does not match what was previously configured, contact our team for further guidance.
The permissions Tess can access are directly determined by what is configured in your SharePoint. The connector only reflects those permissions — it does not create or expand access.
A common configuration that can restrict access is the **Site access** section within SharePoint. If a user or group has limited access to a site, the connector will respect that restriction and will not be able to access content beyond what is permitted.
To review or adjust who has access, open SharePoint, navigate to the desired site, and go to **Site settings** → **Site permissions**.
In the **Connectors** panel, locate SharePoint and click to connect. The credentials form opens.
* Keep the **Authentication method** as `OAuth 2.0`.
* In **Tenant Name**, enter only the tenant name (for example, `your-company` for `your-company.sharepoint.com`). Do not paste the full URL.
* In **SharePoint Subsite** (optional), enter the subsite name that appears in the URL after `/sites/` (for example, `https://tenant.sharepoint.com/sites/`). Leave it blank to use the root site.
Click **Connect**.
If the account is **not an administrator**, Microsoft displays an **Admin approval required** screen. In that case, sign in with an administrator account or ask an administrator to grant permission to the application.
If the account **is an administrator** (or already has the permission), Microsoft shows the **Permissions requested** screen. Review the listed permissions and confirm to authorize access.
The permissions shown on this screen are defined by your organization's SharePoint configuration — Composio acts as a bridge and simply reflects the permissions already set in your tenant. You are not granting new permissions; you are authorizing Composio to use the ones already defined.
The access scope can also be limited by the **Site access** settings within SharePoint. If certain users or groups have restricted access to a site, that restriction is respected by the connector — Composio cannot access content beyond what SharePoint allows for that account.
To review or adjust site access permissions, open SharePoint, go to **Site settings** → **Site permissions**, and check the configured groups and permission levels.
After authorizing, the Tess callback window shows the **Connected successfully!** message and closes automatically after a few seconds.
Back in the **Connectors** panel, SharePoint appears under the **Connected** section, with a green check mark indicating it is active and ready to use in chats and agents.
## Troubleshooting
Check that **Tenant Name** was filled in with only the tenant name (for example, `your-company`) and **not** the full URL (`your-company.sharepoint.com`). An incorrect value can cause Microsoft to return an invalid resource error during OAuth.
The application needs permissions that only an administrator can grant. Ask the SharePoint administrator to sign in first through the connector and grant authorization; after that, other users can connect.
In organizations with an additional federated domain after SSO (with IP blocks or a client certificate requirement on the device), the connection may fail due to corporate environment restrictions. In these cases, a technical alignment with the infrastructure team is required to validate the IdP, federated domains, IP allowlist, and certificates.
Connectors involve access to external systems. Only connect accounts and apps that are appropriate to the usage context, and review permissions carefully.
# Shopify
Source: https://docs.tess.im/en/shopify
Connect Shopify to Tess to work with store, order, and catalog context from chat and agents.
The **Shopify** connector integrates Tess with Shopify. Once connected, the AI can help consult store data such as orders and products and support commerce operations inside chats and agents.
Shopify is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* Access to a Shopify store with the data you need.
* Permission to authorize the Shopify app for that store.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Shopify** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Shopify** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Look up orders and customers** for support or ops routines
* **Inspect products and catalog details** relevant to a task
* **Summarize store activity** for daily or weekly check-ins
* **Support commerce follow-ups** with clearer operational context
* **Help teams answer store questions faster** inside Tess
## Example prompts
> 1. Find order #1042 and summarize payment status, shipping status, and customer email.
> 2. Which products had the highest inventory risk this week?
> 3. Summarize today's new orders and flag anything unfulfilled for more than 24 hours.
> 4. Draft a customer reply about a delayed shipment for order #1042.
## Best practices
* Include order IDs, SKUs, or customer emails when available.
* Ask before making catalog or fulfillment changes.
* In agents, define whether Shopify is for support lookup, ops reporting, or store updates.
## Troubleshooting
Reconnect and approve access for the correct Shopify store.
Reconnect Shopify in Connectors after app uninstall or permission changes.
Confirm the connected store/account can access that resource.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Skills
Source: https://docs.tess.im/en/skills
Skills are “competency packages” that you add in Tess to enable your agents or your chats to perform specific tasks with much more organization, consistency, and efficiency.
Instead of putting huge instructions inside a single agent (which increases cost, confusion, and the chance of hallucination), a Skill works as a ready-made procedure: the agent “opens” the Skill when it needs to, reads the instructions, and executes exactly what was defined.
Think of it this way:
* Agent = the professional (who decides and leads)
* Skill = the process (how to execute a task the right way)
### **What is a Skill**
A Skill is, in practice, an isolated folder with a main instruction file (by default, something like [skill.md](http://skill.md)) , plus other auxiliary files relevant to that competency (templates, images, scripts, code, assets, examples, etc.). In other words, that folder works as a “complete kit” for a task.
### **Why Skills exist (and why that matters)**
A common problem when “training” agents is putting everything in context: dozens of pages of instructions to cover all tasks. This, consequently, increases cost; confuses the agent; increases the risk of hallucination and can even worsen performance on specific tasks.
With Skills, the agent only needs to “read what’s necessary, when it’s necessary”. Even if you have multiple skills available, it will fetch only the ones that will be relevant to the task at hand.
It’s the best of both worlds: the agent has all the necessary potential to brilliantly perform countless tasks, but it only actually uses what’s needed for each one. This improves cost and performance because it reduces tokens consumed unnecessarily and avoids putting everything into context all the time
First, a short “label/metadata” is read to understand whether the Skill makes sense. If so, the agent reads the rest and accesses the Skill’s full files.
Without skills, it’s common for you to need multiple agents (accounts payable, P\&L, analysis, etc.). With skills, you keep the same agent and give it specific procedures per task. The agent becomes a “genius employee” who knows where to find the right procedure.
If you have multiple agents and there is a “common” part among them (e.g., response standard, checklist, template, execution routine), you can turn that into a Skill and reuse it across all of them.
### **Where and how Skills work**
At the moment, Skills are available in Agent Computer, because in this mode we work with a “virtual machine” structure and folders, which makes it possible to navigate files, read instructions, execute scripts, and access assets consistently.
A Skill usually follows this concept:
* Isolated folder: Each Skill is a separate “little box”: its own context, its own files, its own rules.
* Instruction file ([skill.md](http://skill.md)): It is the heart of the Skill: it explains the objective, the step-by-step, and how to use the files contained in the folder.
* Artifacts (support files): It can include images (logos, references), templates, scripts and code (e.g., Python), examples and patterns, or any file useful to accomplish the task
### **How to import Skills into Tess**
You can import Skills from different repositories, either directly from GitHub or by adding the file in your Skill management area:
You paste the repository link in Tess’s skills area (Settings > My account > Skils)
Tess downloads the structure (folders + files) and in a few seconds, the Skill will be available.
Best practices:
* prefer trusted repositories and skills that have a high security ranking within those places
* test in a controlled environment before using in critical tasks
* review the instruction and script content before running any automation
* avoid inserting sensitive tokens directly into conversations/skills
### **Can Skills run code?**
Yes. A Skill can include scripts (e.g., Python) and execution instructions. This allows the agent to:
* execute repetitive tasks
* process data
* generate reports
* automate routines
Practical note: execution usually happens via code execution resources in agent mode and/or via the file management/execution tool (depending on the flow).
# Slack
Source: https://docs.tess.im/en/slack
The **Slack** connector integrates Tess with your Slack workspace. Once connected, the AI can find conversations, summarize channels, and help send updates inside chats and agents.
Slack is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Slack account in the workspace you want to use.
* Permission to authorize the Slack app for that workspace.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Slack** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Slack** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search messages and channels** across accessible conversations
* **Summarize discussions** with decisions, owners, and follow-ups
* **Send messages** to channels or DMs the account can access
* **Support operational updates** without leaving Tess
* **Help teams keep decisions findable** after busy threads
## Example prompts
> 1. Summarize what was discussed in the product channel today and highlight decisions, pending items, and owners.
> 2. Find messages about connectors or integrations and consolidate the main feedback.
> 3. Send a message to #marketing saying the live starts in 10 minutes.
> 4. What were the last decisions in #sales about pricing?
## Best practices
* Use the exact channel name when possible (for example, #product).
* Ask for a draft before sending messages to broad channels.
* In agents, define whether Slack is for reading, summarizing, or posting updates.
## Troubleshooting
Re-run Connect and approve the Slack workspace you intend to use.
Reconnect Slack in Connectors if the app was removed or tokens were revoked.
Confirm the connected account can see that channel or member.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Spaces
Source: https://docs.tess.im/en/spaces
Spaces is the definitive control panel and repository for all files uploaded or generated within your workspace in Tess. It centralizes chat uploads, artifacts generated by autonomous agents, shared bases, and corporate documents in a single secure location. With Spaces, you manage, view, and delete files quickly, optimizing storage and ensuring corporate data compliance.
### What is it?
Unlike local and individual databases (such as the RAG of a specific chat or the restricted memory of an agent in *Agent Studio*), Spaces works as Tess's unified file management system.
It indexes and organizes transparently:
* User Files: Files that you or your team uploaded in everyday conversations.
* Autopilot Artifacts: Files, images, pages, or reports consolidated and autonomously generated by Tess automations.
* Open Spaces, Team Spaces, and Company Space: Shared logical environments for team collaboration.
## Where to find it
Access to Spaces is immediate and located in the product's priority navigation menu:
* Go to the left sidebar of Tess AI.
* The Spaces button is positioned directly below + New chat and just above Agent Studio.
## How to use it?
1. Locate your Files: In the top search bar *"Search files..."*, type the document name to filter data. Use the Filter button to segment files by extension (images, PDFs, text documents, etc.) or by creator.
2. View Content: Identify the file in the table and click the Open button, located in the *Actions* column.
The file will open and in this modal you will be able to download it for a quick check.
3. Delete Individual Files: If you want to delete a specific file for which you have edit permission (indicated by *Edit* in the *Access* column), click Delete in the *Actions* column.
4. Bulk Delete:
* Select the checkboxes to the left of the file names you want to remove.
* Click the Delete selected (X) button that will appear in the upper right corner to clear storage in bulk.
## Understanding the Panel
When analyzing the Spaces table interface, you will find essential informational columns for data governance:
* Name: Displays the original title of the uploaded file and, just below, the associated metadata or instructions (such as act-as prompts or rendering strings).
* Owner: Identifies which user uploaded the document and in which environment it was originally used (e.g., *Chat*, *Agent*).
* Space: Shows the security partition where the file is stored (e.g., *My Files* for the user's personal files in the conversation or *Company Space* for company-wide publicly accessible documents).
* Access: Defines the modification restriction for the document:
* Read only: Files you can view but cannot delete individually or collectively (as they belong to third-party flows or workspace security).
* Edit: Full permission to open or delete the file from the inventory.
**Best practices**
* Validate before Deleting: Always check the links and the Owner before bulk deleting, ensuring the file is not actively being used as a data source (RAG) by any production agent in the company.
* Smart Use of Filters: In large workspaces (with thousands of files), avoid scrolling the page manually. Combine the text search field with category filters to find the desired file in seconds.
## Important notes
* Administrative Permissions: Regular users can only see their own uploads privately in Spaces. Only workspace *Owners* and *Managers* have the global view and the ability to view or delete files from the entire team for audits.
* Impact of Deletion: Keep in mind that removing a file from the Spaces panel permanently unlinks it from the platform's resources.
*When deleting a file from Spaces that was originally uploaded in a conversation, the attachment is permanently removed from that chat's knowledge base.*
By consolidating the entire file ecosystem under a single governance interface, Spaces ensures that your company maintains regulatory data compliance, full historical visibility, and absolute control over cloud infrastructure costs.
# Stripe
Source: https://docs.tess.im/en/stripe
The **Stripe** connector integrates Tess with Stripe. Once connected, the AI can help consult customers, payments, and billing-related context inside chats and agents, within the permissions of the connected Stripe account.
Stripe is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* Access to a Stripe account with the data you need.
* Permission to authorize the Stripe connection for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Stripe** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Stripe** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Look up customers and payment status** for support or finance routines
* **Summarize billing context** around invoices, subscriptions, or recent charges when available
* **Support operational follow-ups** with clearer payment signals
* **Help teams answer billing questions faster** without leaving Tess
* **Keep sensitive actions cautious** by asking for confirmation before changes
## Example prompts
> 1. Find the Stripe customer for Ana Silva and summarize her latest payment status.
> 2. Which open invoices are overdue by more than 7 days?
> 3. Summarize subscription changes from the last 24 hours.
> 4. Draft a support reply explaining a failed card charge for customer cus\_123.
## Best practices
* Prefer customer IDs, emails, or invoice IDs when you have them.
* Ask for confirmation before refunds or subscription changes.
* In agents, define whether Stripe is for lookup, reporting, or billing actions.
## Troubleshooting
Reconnect with a Stripe account/user that can access the needed mode (test/live) and data.
Reconnect Stripe in Connectors after key/permission changes.
Confirm you are looking in the correct Stripe account/mode and that the connected user can access that object.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Supported Files
Source: https://docs.tess.im/en/supported-files
The Tess chat lets you attach files so the AI can read, analyze, summarize, extract information, transcribe content, or help you work with data and code. You can upload documents, spreadsheets, presentations, media files, images, and many programming formats.
The type of file you upload defines the processing workflow used by the platform.
## What is it?
File support in chat lets you include external content directly in the conversation as context for the AI.
In practice, you can:
* Summarize a PDF or Word document;
* Analyze data from a CSV or Excel spreadsheet;
* Extract information from a presentation;
* Transcribe and analyze audio and video;
* Review, explain, or fix code files;
* Ask questions about images attached to the chat.
After attaching the file, send a **Prompt** explaining what you want to do. Tess will use the available content within the context window and the workflow that matches the format to generate the response.
## How to use it?
1. **Attach a file** to the chat.
2. **Wait for processing** to finish before sending more complex requests.
3. Write a clear Prompt indicating the expected result.
4. If needed, ask follow-up questions in the same conversation to go deeper into the file analysis.
## Supported formats
### Documents and data
| Category | Supported extensions |
| :--------------- | :------------------- |
| Text | `.txt` |
| Word | `.doc`, `.docx` |
| PDF | `.pdf` |
| CSV spreadsheets | `.csv` |
| Excel | `.xls`, `.xlsx` |
| Parquet | `.parquet` |
| Presentations | `.ppt`, `.pptx` |
| Markdown | `.md` |
These files can be used for tasks such as summarization, information extraction, content comparison, data analysis, and creating responses based on the uploaded material.
### Audio and video
| Category | Supported extensions |
| :------- | :------------------------------------------------------- |
| Video | `.mp4`, `.avi`, `.mov`, `.mkv`, `.wmv`, `.flv` |
| Audio | `.mp3`, `.wav`, `.aac`, `.ogg`, `.flac`, `.m4a`, `.opus` |
Audio and video files are processed with transcription via **Deepgram**. After processing, you can ask questions about the spoken content, request summaries, identify topics, and extract decisions or next steps.
Media processing may consume more credits than text files, because it involves transcription before AI analysis.
### Images — available in chat
| Supported extensions |
| :---------------------------------------------------------------- |
| `.jpg`, `.jpeg`, `.png`, `.gif`, `.bmp`, `.svg`, `.tiff`, `.webp` |
In chat, you can attach images and ask the AI to describe them, extract visual information, compare elements, or generate analyses from the displayed content.
### Code files
Tess also accepts several code and configuration file formats. All of them follow the same processing workflow for code.
| Category | Supported extensions |
| :--------------------- | :-------------------------------------------------------------- |
| Web | `.html`, `.htm`, `.css`, `.scss`, `.js`, `.ts` |
| Data and configuration | `.json`, `.xml`, `.yml`, `.yaml`, `.sql` |
| Scripts | `.bat`, `.ps1`, `.sh`, `.py`, `.r`, `.pl`, `.php`, `.lua` |
| Languages | `.bas`, `.dart`, `.inc`, `.kt`, `.pas`, `.swift`, `.vb`, `.vba` |
| Diagrams and others | `.vsd`, `.md` |
With these files, you can ask for explanations, logic review, error identification, documentation, improvement suggestions, and conversion between languages or formats.
## Deeper explanation
Each format accepted by Tess is associated with a **processing workflow**. That workflow defines how the content will be prepared for use in chat.
In general:
* **Documents, spreadsheets, and code** may use `smart_search` mode, which locates relevant parts of the file before generating the response.
* **Audio and video** use transcription via **Deepgram** before analysis.
* **Images** are processed as visual content in chat and in the API.
* The **Web Scrapper** feature is available only in the chat context and does not correspond to a file uploaded by the user.
## Practical examples
### Summarize a contract in PDF
Attach the `.pdf` file and use:
```text theme={null}
Summarize this contract in plain language.
Highlight obligations, deadlines, penalties, risks, and clauses
that require attention.
```
### Analyze a results spreadsheet
Attach a `.csv` or `.xlsx` file and use:
```text theme={null}
Analyze the data in this spreadsheet.
Show trends, outlier values, and improvement opportunities
in an objective table.
```
### Review a code file
Attach a `.py`, `.js`, or another supported format and use:
```text theme={null}
Review this code, identify possible bugs, and suggest improvements
in readability, security, and performance. Explain each suggestion.
```
### Extract decisions from a recorded meeting
Attach an audio or video file and use:
```text theme={null}
Transcribe and summarize this meeting. List decisions made, owners,
mentioned deadlines, and next steps.
```
### Analyze an image
Attach an image in chat and use:
```text theme={null}
Analyze this image and describe the main visual elements.
Then extract any visible text and organize it into topics.
```
**SMART PROCESSING**
We use smart processing that identifies the same content already processed in Tess to avoid processing it again. So even if the file name is different and the content is the same, once it has been processed once, we will reference the original one.
## Important notes
* Uploading and processing files may consume **credits**, especially in tasks that involve advanced models, analysis of large files, audio, and video.
* Very large files or files with a large volume of content may take longer to process and may be analyzed in parts, according to the model's context window.
* For audio and video, transcription quality may vary depending on language, noise, multiple speakers, and recording quality.
* **Web Scrapper** is a chat-specific feature for web content and is not a file format for upload.
# Tess 6.1
Source: https://docs.tess.im/en/tess-6-1
Tess 6.1 offers an agentic orchestration experience of different models for the execution of a single complex task. You give your prompt and, instead of using just one LLM to respond to your request, this model activates a Multi-LLM architecture in a single request: multiple models work in a chain, collaboratively, reviewing and refining each other's work before you receive the final response.
In practice: you ask a question as you always do. Behind the scenes, different AI models discuss, refine, and consolidate a joint response — and you receive the result ready, in a single message.
### **What is Tess 6.1**
Tess 6.1 is an orchestrated model of robust collaboration between LLMs, designed to:
* combine the strengths of different models
* reduce errors and contradictions in complex tasks
* deliver more consistent, structured, and "thought-through" responses with a single prompt
When you select it in the chat, Tess:
* activates the Multi-LLM mechanism for that message
* coordinates collaboration between multiple state-of-the-art models
* returns a single, already consolidated response, also presenting the entire chain of reasoning from each model throughout the delivery flow
When to use Tess 6.1 (and when you don't need to)
* The topic is complex or strategic
* You need "thought-through" and well-structured responses
* There are multiple reasoning steps involved
* The task is quick and simple
* The focus is cost/speed, not depth
* Exploring ideas without rigor
**Important**
* Even though it is Multi-Model, this does not replace human validation on critical topics (legal, financial, medical, high-impact decisions).
* It will naturally take a few extra seconds to generate the final response, due to the nature of the model.
* It is not the best option for quick and low-cost tasks (short responses, minor adjustments).
* Because it uses multiple models, any differences in "style" between them are harmonized, but may appear in very extreme tone/style requests; if this occurs, be very specific about the desired tone.
# Tess Consensus
Source: https://docs.tess.im/en/tess-consensus
Each artificial intelligence model is trained based on specific data, contexts, and guidelines — which means each one carries its own "bias" in how it interprets and responds to problems.
In a professional context, this goes far beyond right or wrong: it is about understanding how different perspectives influence answers and, consequently, decisions.
Why ask a single AI when you can consult the top three?
Tess Consensus was developed exactly to solve this challenge.
### **So, what is Tess Consensus?**
It is an agentic technology that **orchestrates multiple AI models simultaneously**, promoting a "conversation" between them. Instead of returning a single isolated answer, it conducts a collaborative process where the models analyze, refine, and validate their own outputs until reaching a more robust result.
This process generates something fundamental: consensus with greater reliability.
Unlike a simple comparison between individual answers, the Consensus creates an additional validation layer, where the models:
* Debate among themselves
* Adjust inconsistencies
* Converge on the best possible answer
The result is a delivery with higher quality, more consistency, and better performance.
### **Why "consensus" and not just comparison?**
Comparing the answer of two isolated models is not enough to identify bias with statistical confidence. A single output does not necessarily represent the actual behavior of that model.
**Tess Consensus solves this by:**
1. Running multiple models per group (e.g., models with greater Western or Eastern influence)
2. Generating an internal consensus among them
3. Producing a statistically more reliable result
Only then does it make sense to compare different consensuses.
That is why we launched at Tess three separate approaches such as:
1. Consensus Global
2. Consensus US
3. Consensus China
Each one represents a collective construction within a specific context — and not just the isolated opinion of a model.
Consensus only works in standard Chat Mode and not in Agent Mode.
### **Main features**
The top three global models work together to solve complex problems, combining their capabilities and reducing individual failures.
Allows for a structured comparison of different worldviews — Western and Eastern — based on independent consensuses. This ensures a fairer and methodologically correct analysis.
**Bias identification:** By comparing consensuses, you can observe real divergences in interpretation, revealing how cultural, corporate, and training factors impact the results.
**High performance through self-validation:** When multiple models collaborate and mutually validate each other, the quality of the answer tends to surpass traditional benchmarks. The Consensus acts as an "intelligent cross-checking" mechanism.
### **How does this apply in practice?**
TESS Consensus was not created for superficial curiosities like "how a Chinese or American model thinks". It is a strategic tool, aimed at deeper decisions.
Examples of use:
* HR strategies adapted to different cultures
* Definition of business personas with greater precision
* Market analysis with multiple perspectives
* Decision-making in complex and ambiguous scenarios
In many cases, different models diverge significantly. By promoting dialogue between them, the Consensus reduces noise and increases clarity.
Furthermore, in scenarios where one intentionally wants to apply a cultural bias (for example, adapting an operation to the Chinese context), using a specific consensus is more effective than relying on a single model — especially considering that many models share similar training influences.
### **Why is this a game changer?**
Tess Consensus transforms the way professionals use AI:
* Moves from isolated answers to well-founded decisions
* Introduces transparency in the use of models
* Allows understanding and exploring different perspectives
* Raises the level of confidence in the answers
More than a text generation tool, it is a mechanism for quality and performance.
Create, test, and share
The true potential of Tess Consensus appears when applied to real problems.
Explore different consensuses, compare results, and observe how the transparency of the models directly impacts the quality of your decisions.
We built the stage. Now it's up to you.
# Tess Pages
Source: https://docs.tess.im/en/tess-pages
We have made the process of publishing your website on the web simpler and faster than ever. With Tess Pages, you can create and publish your page on the platform (whether it's a landing page, a form, a dashboard, a presentation, etc.), using the chat itself.
Tess Pages is Tess's instant cloud feature, a solution for publishing pages with a single command.
### **What is Instant Cloud?**
Instant Cloud is the tool that transforms your files into active, accessible web pages, which we call Tess Pages. With a simple command, you can host your documents directly on the Tess infrastructure, generating a public link to share with whoever you want.
It is the fastest and easiest way to get your content online, with no technical knowledge required. The complexity of hosting a website has been reduced to a simple request.
### **What can I publish?**
The possibilities are vast. You can use Instant Cloud to publish:
Create the HTML of your page and publish it instantly.
Share slides from a project or a class.
Make forms available to your audience and use the API to send responses anywhere.
Create a static website with photos or products and put it online in seconds.
### User Safety and Content Guidelines
These guidelines rest on three pillars:
* **Responsible freedom of creation:** Tess exists to expand the human capacity to create, automate, and publish. We respect the diversity of expression - whether for commercial, educational, artistic, or professional use - within legal limits and the bounds of these guidelines.
* **Safety first:** The Safety of users, visitors to published pages, clients of embedded agents, and our team is a priority. Content or conduct that puts people at risk is not tolerated.
* **Fair treatment:** Rules apply consistently to all users, regardless of plan, usage volume, or location - subject to specific legal obligations by jurisdiction.
Use of Tess is intended for individuals "18 years of age or older"; if you use the platform on behalf of a minor, you must be a parent or legal guardian and agree to these guidelines on your own behalf and on behalf of the minor.
You must not submit, generate, publish, or make available content that:
* Infringes upon the copyrights, trademarks, patents, trade secrets, or other intellectual property rights of third parties;
* Reproduces protected works without authorization or a valid license;
* Uses the visual identity, name, or content of third parties confusingly or misleadingly.
Tess does not mandate an absolute ban on adult content when shared lawfully and within an appropriate context (e.g., for educational, artistic, medical, or journalistic purposes), provided it complies with the laws applicable to both the publisher and the target audience.
However, we maintain a Zero-Tolerance Policy regarding:
* CSAM (Child Sexual Abuse Material), in any form - whether real, simulated, or fictional.
* NCII (Non-Consensual Intimate Imagery);
* Grooming and the sexual exploitation of minors;
* Sexual content directed at minors or that sexualizes minors.
Upon identifying or receiving a report of CSAM, we will immediately remove the content and report it to the competent authorities, including - where applicable - channels provided by SaferNet and other relevant Brazilian agencies.
It is prohibited to use Tess — including Tess Pages, Public Pages, embedded agents, and automations — for:
* phishing, social engineering, or the fraudulent acquisition of credentials, financial data, or personal information;
* spam, unsolicited bulk messaging, or abusive marketing practices;
* pyramid schemes, Ponzi schemes, chain letters, or misleading promises of financial returns;
* pages or agents designed primarily to deceive visitors or end-users;
* impersonating financial institutions, governments, companies, or individuals.
You must not use Tess to:
* create, distribute, or execute viruses, malware, ransomware, Trojans, worms, or malicious code;
* conduct denial-of-service attacks, system intrusions, or vulnerability exploits;
* publish pages or agents that collect visitor data without transparency or an appropriate legal basis;
* bypass security measures, rate limits, authentication, or platform usage controls.
It is prohibited to:
* publish third-party personal data without express and informed consent, when required by law;
* impersonate living or deceased individuals, companies, or public entities;
* create synthetic, manipulated, or out-of-context content (deepfakes, altered audio/video, fabricated documents) intended to deceive people and cause harm—especially regarding public health, safety, elections, or crises;
* falsely claim that Tess, Meta, or third parties endorse your content, representative, or published page.
Tess was not designed to facilitate harassment campaigns against private individuals.
It is prohibited to:
* humiliate, threaten, stalk, or publicly expose individuals without a legitimate basis and consent, where applicable;
* publish content with the primary purpose of degrading or abusively exposing someone;
* coordinate mass harassment attacks via agents, automation, or published pages.
**Legitimate criticism, opinion, and feedback**—including negative reviews of products or services—are permitted provided they are honest and do not violate other sections of these guidelines. Fake, repetitive, paid, or manipulated reviews are not permitted.
Content or conduct that does the following is prohibited:
* makes **credible calls for violence** against individuals or protected groups;
* incites hatred, discrimination, or systematic degradation based on race, ethnicity, national origin, religion, gender, gender identity, sexual orientation, disability, or other characteristics protected by law;
* glorifies, promotes, or provides instructions for violent or terrorist acts;
* represents or supports terrorist organizations, violent extremist groups, or groups that systematically target civilians.
We recognize that the boundaries between legitimate opinion and prohibited speech can be complex and sensitive to cultural and legal contexts. We will evaluate each case based on this Policy, applicable law, and the potential for harm.
It is prohibited to use Tess to offer, sell, buy, facilitate, or promote:
* illicit drugs or controlled substances outside of legal channels;
* human trafficking or human exploitation;
* products derived from endangered species or of illicit origin;
* weapons, ammunition, or explosives in violation of applicable laws, or instructions for illegal manufacturing;
* unauthorized gambling, betting, or online casinos;
* unregulated financial services, money laundering, or tax evasion;
* any product or service the sale of which is illegal in the jurisdiction of the publisher or the target audience.
To protect users and visitors, we do not allow content that:
* promotes, glorifies, or encourages suicide, self-harm, or eating disorders;
* provides detailed instructions on methods of self-harm, suicide, or concealing disorders;
* is part of "pro-ana" movements or the like;
* targets minors with self-harm content.
**Educational, prevention, or support content** — published in good faith to raise awareness or provide help — will be evaluated based on context and intent.
If you or someone you know is in crisis:
* **CVV (Life Appreciation Center):** call **188** (24h, toll-free) or visit [cvv.org.br](http://cvv.org.br))
* **Emergency:** call **192** (SAMU/Ambulance) or **190** (Police)
It is prohibited to input, process, publish, or expose the following via Tess:
* **sensitive personal data** without a legal basis, adequate security measures, and access controls, in accordance with the LGPD;
* **protected health information** (including identifiable clinical data) in contexts requiring specific regulatory safeguards, unless covered by an enterprise contract with applicable clauses;
* **financial, biometric, or minors' data** on public pages, embedded agents, or Tess Pages without adequate consent and protection;
* **state secrets, classified information, or data subject to legal confidentiality** without authorization.
### **How It Works: A Step-by-Step Guide**
The workflow is incredibly straightforward. Follow these steps:
The first step is to have your .html file ready and available in the conversation context. You can do this in two ways:
* Creating the file on the spot: Use the Manage Files tool to write the HTML code for a website directly in the chat.
* Uploading an existing file: Upload your ready-made HTML file when using one of the tools that allow attachments, such as Manage Files or Deep Analysis.
In the "Tools" menu, select the "Manage Files" or "Deep Analysis" option
Ask for the HTML file to be generated as a preview in Tess, so you can see the result as a preview and make any necessary adjustments.
With the file available in the chat, simply give the AI a clear command. No complex configurations needed. Just ask.
Command Examples:
* "Publish this HTML file as a website."
* "Create a Tess Page with the file my-site.html."
* "I want to publish this website. Generate the link for me."
**Done! Your Website Is Live!**
The AI will process your request and provide the public link to your new Tess Page. Simple as that! Your content will be instantly accessible to the world.
**Important Information:**
To ensure the best experience, keep two simple rules in mind:
* Custom Subdomain: You are free to choose a custom subdomain for your website (e.g.: [my-amazing-project.tess.page](http://my-amazing-project.tess.page)). However, the chosen name cannot already be in use on the platform. Be creative!
* One Website per Chat: Each chat conversation is limited to publishing a single website. If you publish a new file in the same chat, it will replace the previous website. To publish a second website, simply start a new chat.
See an Example in Action
Want to see how it looks? Check out this example page, published directly from the platform with this new feature:
Page Link: [https://ai-course.tess.page](https://ai-course.tess.page)
This new feature removes technical barriers and makes web publishing a fast and intuitive task, integrated into your workflow on Tess. Create, publish, and share your ideas with the world in just a few minutes.
# Chat Tools
Source: https://docs.tess.im/en/tools
Chat Tools or Chat Tools are resources that allow LLMs to do more than just “talk” to you. With these tools, you can search the internet, generate images and videos, create music and voiceover, analyze data, manipulate files, and trigger integrations/automation — all in the same conversation and using the context of what has already been discussed.
This is what differentiates the professional use of AI - the interaction between models and professional tools, to maximize the user’s reach and performance in their practical use cases.
## What are Tools?
They are additional capabilities that Chat can trigger on demand. In practice, they turn the chat into an “execution panel” for real tasks, not just text answers.
Examples of what Tools allow:
* Create image, video, music, and voiceover from prompts
* Edit videos and improve quality (upscale, chroma key, etc.)
* Analyze large spreadsheets/CSVs, perform mathematical operations and complex calculations, and generate insights - Deep Analysis
* Read, edit, and transform files of all types - Manage Files
* Trigger automations and connect with apps - Integrations
* Work with voice (Speech) and audio (Music)
## **Where to find them and how to use them in Chat?**
On the chat screen, near the message box, there is a tools button (an icon similar to the volume sliders on a sound mixing desk).
When you click it, a menu opens with the list of available Tools. Choose the tool you want to use, make your request in natural language, explaining the objective and, if you have them, providing the necessary files/links. By clicking the info button next to each tool, you’ll find a brief explanation of its applicability.
If you see the need for adjustments, variations, improvements, and revisions, just let the chat know and the LLM will use the conversation context to refine without starting over from scratch.
### **Main Chat Tools (overview)**
1. Internet: For different types of web research. Search engine searches, social media queries, Deep Research (for more elaborate research), academic mode.
2. Images: Create images within the chat itself, using one of several available models, such as Nano Banana, TESS 6, GPT 5 Image, Ideogram 3, etc. There are also editing options, such as background removal, upscale, and vectorization (SVG).
3. Videos: Create images within the chat itself, using one of several available models, such as Sora, TESS 6, Google VEO, Kling AI, etc.
4. Video Editing: Video editing, with tools such as Film Maker (stitching clips together), Frame Extraction, upscale, angle changes, visual effects, Chroma Key Background, etc.
5. Speech (Voiceover / Voice): To convert text into voice and create voiceovers. Ideal for voiceovers, classes, podcasts, videos, and presentations.
6. Music (Music): To generate soundtracks, jingles, and songs from prompts (genre, BPM, instruments, mood, duration). Ideal for content, videos, intros/outros, and background music.
7. Deep Analysis (Deep Analyses): For advanced data analysis and machine learning on spreadsheets, CSVs, and structured datasets. Ideal for reports, segmentation, usage patterns, churn, trends, and metrics diagnosis. Tip: always use it with robust AI models and write more literal prompts.
8. Manage Files (File Management): To access, read, and modify files (documents, PDFs, GIFs, and others). Ideal for reviewing documents, extracting information, reorganizing files, and generating edited versions. Tip: always use it with robust AI models and write more literal prompts.
9. Integrations (Integrations / Automations): To connect the chat to automations and apps via platforms like Zapier, Make, and n8n (and/or HTTP calls), enabling you to trigger tasks such as: sending emails, creating tickets/tasks, updating spreadsheets and CRMs, notifying teams in Slack/Teams, etc.
10. Avatar: Create avatars within the chat itself, using one of several available models, such as HeyGen, OmniHuman, and Wan.
11. No Tools: Disables tool usage (text only).
# Video Editing
Source: https://docs.tess.im/en/video-edit
Edit, enhance, and transform videos directly from the Tess chat using advanced post-production tools. From background removal to 4K upscaling, all without leaving the platform — and better yet, right from the chat!
**What is this Tool?**
The Video Editing tool in the Tess Chat offers 7 specialized post-production features:
Natural-language video edits with optional reference keyframes — retexturing, object removal, style changes while keeping untouched parts consistent
Automatic background removal and replacement with a green screen
Resolution increase up to 4x (to HD or 4K)
Merging clips with signaled transitions to generate a film
Generation and combination of audio from prompts or video
Captures the last frame of the uploaded video as a static image
Character replacement and animation while preserving original movement
### **Why it matters**
With the Video Editing Tools, you can perform professional editing without complex tools. After all, you can:
* Finalize AI-generated or externally recorded videos
* Prepare content for production (chroma key, upscaling)
* Create visual narratives by combining multiple clips
* Add professional audio layers
* Reuse frames to ensure visual continuity
All of this without needing to master traditional editing software like Premiere, After Effects, or DaVinci Resolve.
Choose the desired feature from the tools above, upload the video (or videos) you want to edit, and describe the desired edit (depending on the tool). Wait for processing and download the result!
### **Understanding the Available Tools**
Advanced editing with natural-language instructions: retexture objects, remove elements, change style, or adjust angles while keeping untouched parts of the scene consistent. Optional **reference keyframes** let you pin precise looks at specific moments in the clip.
Use it when you need to adjust colors/textures without re-recording, remove unwanted objects, experiment with alternative looks, or guide edits with keyframes.
Example use: "Change the car color from blue to red, keep the rest of the scene intact." The expected result is the same video with the car retextured in red, without affecting other elements.
**Screenshot placeholder — Aleph 2.0:** Capture the Video Editing tools list with **Runway Aleph 2.0** selected, optionally showing a keyframe/reference upload field.
Perfect for automatic background removal and replacement with a green screen (chroma key). Makes it easier to apply custom backgrounds later in any editor.
Use it to prepare videos for compositing in professional editors, when you need to isolate a subject/character from the background, or to create content with virtual backgrounds or dynamic scenarios.
Recommended workflow:
* Upload the video with the background you want to remove
* Automatic processing – the AI removes the background
* Download the video with the green screen
* Import into an editor (Premiere, After Effects, etc.) and add a new background
Resolution increase up to 4x with AI. It is the ideal tool for improving video sharpness, reducing distortions and noise, and making it easier to view details lost due to low quality.
If you have old or low-resolution videos that need a quality upgrade, this tool will help you. Or if you want to improve the quality of AI-generated videos.
Limitations:
* Does not create non-existent details – it only enhances what already exists
* Processing time may vary depending on the video duration
Merging clips with professional transitions — that is, it is capable of joining multiple video clips into a single sequence, with smooth transitions between them (or without transitions, when specified).
Use it to create visual narratives from multiple clips, put together promotional videos, showreels, or storytelling, or to join separately generated scenes into a single fluid video.
Recommended workflow:
* Upload the clips in the desired order
* Choose the transition style (fade, hard cut, dissolve, etc.)
* Processing – the AI joins the clips with natural transitions
Transition types:
* Fade: Gradual darkening effect, ideal for dramatic scene changes
* Dissolve: Gradual overlap effect, used for time passages
* Cut: Direct cut effect, used for fast-paced rhythm and action
* Slide: Lateral sliding effect, for spatial connection between scenes
Audio generation and combination tool for video. It can generate audio from text prompts or visual video content, combine multiple audio tracks into a single video, and overlay sound layers (music, narration, effects, ambience).
Use it to add a soundtrack to silent videos, create custom soundscapes, overlay narration, background music and sound effects, etc.
This tool is perfect for capturing the last frame as a static image (JPEG/PNG).
Its use is recommended for creating continuity between AI-generated videos using the extracted static image. In this case, use the last frame of Video A as the first frame of Video B for naturally perfect and fluid transitions, or use it to create custom thumbnails, etc.
The Wan 2.2 Animate models allow you to replace characters in reference videos while maintaining the original movement, or transfer movement from one video to a new scene with a different character and background.
Operation modes:
1. Animate Replace Mode (Character Replacement)
* Input: Original video + image of the new character
* Output: Video with the new character performing the same movements
* Preserves: Movement, original setting
2. Animate Animation Mode (Copy Movement)
* Input: Reference video (movement) + character image + new scene
* Output: New video with an animated character performing the movement from the original video
* Preserves: Movement
* Replaces: Character and background
**Tips**
* Use videos with good lighting and adequate resolution
* Avoid heavily compressed videos or those with excessive noise
* Start with short clips before processing longer videos
* Upscale 4x → Chroma Key → Film Maker → Sound to Video
* Create complete post-production pipelines within Tess
Tess's Video Editing tools democratize professional post-production.
Combine these 7 tools to create complete workflows — from generation to finishing — without leaving the platform.
# Video Generation
Source: https://docs.tess.im/en/videos
The Video Tools let you turn a prompt (text description) into video clips. Within the “Tools” menu in the chat, you can choose between different video generation models, each with its own style and behavior, to reach the ideal result for your project more quickly.
### **Where to find the Video Tools**
1. Open the chat
2. Click the Tools button (last icon at the bottom left of the message box)
3. Look for the tools section/list and select a Video tool
Within the video Tools, you’ll see options for several video generation models, such as:
1. Tess 6
2. Kling
3. Runway
4. Sora
5. VEO
6. Wan
7. Seedance
8. Hailou
9. Happy Horse 1.0 (text-to-video and image-to-video; 720p/1080p; 3–15s)
10. Grok Imagine Video 1.5 (image-to-video with synchronized audio)
After selecting one of the AIs, write your prompt and ask it to generate the video.
**Screenshot placeholder — video model picker:** Capture the Video tools list with **Happy Horse 1.0** and **Grok Imagine Video** visible (chat → Tools → Video).
### **Why are there several video tools/models?**
Because each model interprets prompts in a different way and tends to stand out in specific styles. In practice, having several models gives you more aesthetic options (realistic, animated, cinematic, etc.), more chances to nail your project’s look with less trial and error, and greater flexibility to test the same prompt in different models and choose the best result.
### **How to use the Video Tools**
In the Video Tools menu, choose one of the models from the list. Then write a prompt thinking in terms of “movement”, since video is not just appearance; it’s action, camera, and duration.
* Subject: what appears
* Action: what happens
* Environment: where it happens
* Camera movement: static, travelling, close-up, slow motion...
* Style: cinematic, realistic, animation, etc.
* Aspect ratio (if needed): 9:16, 16:9, 1:1
* “Aerial travelling shot over a dense, foggy forest at dawn; sunrays cut through the mist and reveal a winding river.”
* “Close-up of hands typing on a mechanical keyboard, blue and purple neon light, shallow depth of field, stable camera.”
Generate the clip and check whether the action is clear, whether the style matches your expectations, and whether there is visual consistency (objects “changing” too much). Video generation is highly iterative; with each improvement and refinement, you’ll move toward better practice and achieve increasingly satisfying results. Test 2 or 3 models with the same prompt when aesthetics are important.
The same prompt can generate very different results depending on the model. A simple exercise is to write a very detailed prompt, generate it in two different models, and compare: realism, camera movement, consistency (objects/face/hands), “mood”, and lighting.
The models that generate videos with sound (speech or sound effects) include Wan, Veo, Sora, and **Grok Imagine Video** (synchronized audio). They can therefore consume more credits, but if you need this feature, the ideal is to work with one of them. If what you need is a simpler motion or animation, the other models will not only be less costly but will also be able to meet your needs well.
**Happy Horse 1.0** is a strong option for short clips from a text prompt or by animating a still image, with common aspect ratios for text-to-video.
# Voiceover
Source: https://docs.tess.im/en/voiceover
Transform text into professional narration using the 5 best audio models in the world. Generate, edit, and customize studio-quality audio — all in natural language, directly from the Tess chat.
In practice, it is like having a "cast of voice actors" available on demand to create voiceovers, training audio, podcasts, social media content, and much more.
### **How to use the feature in the Tess chat**
The Audio tool in the Tess Chat allows you to create professional narrations from text using 5 specialized models:
* Orpheus Speech — 4 professional voices for corporate contexts
* ElevenLabs Speech — All voices + ultra-realistic custom IDs
* OpenAI Speech — 6 premium voices with exceptional naturalness
* Gemini Speech — 30 voices + the only one with dual narration in 24 languages
* Voice Changer — Voice transformation preserving emotions
Each model/voice has different characteristics (timbre, intonation, naturalness, a more corporate or more relaxed "feel"). This helps you choose the ideal voice for each context, such as an institutional video, educational content, an advertisement, or a more "human" narration.
### Practical applications (where narration shines)
When used to enhance YouTube videos, Reels, TikTok, ads with a voice narrating the content.
Creating audio versions of written materials such as articles, scripts, and book chapters.
Used for narrations in lessons of various focuses (subjects, languages, etc.), tool presentation modules and onboarding, among others.
Also well applied to generate audio for presentations (executive or results-based), internal materials, product guides, support scripts, etc.
### **Tips for professional-quality narration**
1. Write as if it were "spoken" — use punctuation to your advantage. Commas and periods control pauses and speech rhythm. Dashes can be good for emphasis, and lists with line breaks are often clearer when listened to.
2. You can also spell out acronyms in full (e.g.: "Customer Success" instead of "CS") when necessary, or guide pronunciation in the text (e.g.: "Tess (pronounced 'Tés')").
3. Make short versions and test — before narrating a long script, generate 10–20 seconds to validate the chosen voice and clarity.
**Generated Audio Link:** [**Listen to Narration**](https://storage.googleapis.com/app-tess-ai-platform-assets-prod/eleven-labs/1dfc91a0-eeda-4c2f-94ec-5a98ecaa2099.mp3)
**Voice Changer**
The Voice Changer can be used to transform one voice into another from an existing audio file. It is great for:
* characters and creative content
* timbre standardization in video series
* "persona" adjustments for the brand
### **Credit consumption**
Narration and audio tools generally consume more credits than a text chat, because they involve additional processing. If you want to optimize costs:
* test on short excerpts first
* finalize the script before generating the full version
* maintain a consistent voice/model standard to avoid rework
# AI Wallet
Source: https://docs.tess.im/en/wallet
The Credit Wallet (AI Wallet) is the control center for your credits on Tess. It shows how much you still have available in your Workspace.
### **Where to find the Credit Wallet**
The Wallet is visible in the upper right corner of Tess on the chat screen, or image/video generators, next to a small yellow coin icon.
Here you can see, in real time, the available credit balance of the workspace (not per user, but at the general Workspace level).
Credits that have a monthly refill (and expire) are shown under Monthly Credits. Credits purchased separately fall under the "Purchased Credits" option.
### **What are credits and how do they work**
Credits are the "currency" of Tess. Depending on the action you perform in Tess, it may have a cost and the consumption comes from this credit wallet, for example:
\
Sending messages is a form of consumption and depends on the size of the conversation and also on the chosen model. The more robust models tend to consume more credits per exchange compared to older ones, but they perform better on more complex tasks.
\
Activating Max Mode, by expanding the reach of the working context window, ends up sending the model much more previous content, in order to accommodate the entire history up to the maximum window of each model. More memory, more cost — which is why it is a feature that should be activated on demand.
\
When you attach files to the Knowledge Base, they also need to be processed and made available in your account's library. This document processing procedure deducts from your credits and is a one-time charge per document. However, the use of AI for token reading consumes resources.
\
The process of generating images, videos, avatars, music, narrations, and podcasts through the Tess chat are all done with AI and, for each of them, there is a specific cost tied to the process. In addition, the use of tools (Tools) such as Deep Analysis and Manage Files can also generate costs in your credit wallet.
### **Behind this are tokens:**
* **Input tokens:** everything you send to the AI and then what is sent as chat context
* **Output tokens:** everything the AI generates as a response
The cost in credits is calculated based on the number of tokens processed and the type of resource used.
The Credit Wallet, together with the Execution History, provides full transparency on how AI is being used in your workspace.
You pay for the credits consumed, with transparency and predictability — and you have the freedom to choose the model and configuration that makes the most sense for each task. To understand exactly where your credits are being used, Tess offers the Execution History.
For any questions, contact our team at: [support@tess.im](mailto:support@tess.im).
# Welcome to Tess
Source: https://docs.tess.im/en/welcome
Tess is an AI autonomous agent orchestration platform designed to execute complex tasks and deliver professional results.
With Tess, professionals and companies can join the Vibe Working Era, unlocking new professionals skills and improving substantiallly their own performance.
Tess Agent Computer operates through a virtual computer with full internet access, orchestrating hundreds of models to execute complex tasks.
Tess Agent keeps running even when you close the tab or turn off your device. Our agent retains context across long-running tasks and delivers production-ready results — without requiring you to manage every step along the way.
## Why Use Tess?
Unlike traditional chat tools that simply answer questions, Tess orchestrates collaboration between 250+ specialized AI models to generate superior quality outputs - taking action and delivering actual results.
Think of Tess as a team of AI experts, each a specialist in their field—text, image, video, code, audio, etc.—working together in a coordinated way to complete tasks from start to finish, with up to 8x better performance than single-model platforms.
Traditional AI tools require constant supervision and manual intervention — you guide them step by step, then manually piece together the results yourself. Tess works differently. It independently plans, executes, and sees tasks through to completion, delivering exactly what you need: a custom tool, a slide presentation, a market research report, or virtually anything else you have in mind.
## Intelligent Model Orchestration
We believe that **no single AI is better than all of them working together.** Tess is not just a model aggregator—we are the orchestration layer that allows hundreds of specialized AIs to collaborate intelligently through a single interface and with a unique agentic approach.
When you request a task, Tess:
* Analyzes which model is best suited for each step
* Orchestrates collaboration between multiple specialized models
* Integrates the results into a cohesive and professional final output
* **Result:** Up to 8x higher performance in creative quality, task accuracy, and business insight generation.
## Unlimited Collaboration
We are the first AI platform with a shared wallet system. Instead of charging per user, we allow unlimited users per workspace — ideal for families, teams, and businesses.
## Total Transparency
Tess adopts a unique market positioning: we are committed to being the most transparent AI platform in the world – no hidden caps, no "fair use" clauses. With Tess, you:
* Know exactly how many credits you have purchased and can monitor your balance in real time in your AI Wallet.
* Are informed – before and after – of the concrete or estimated cost for executing each task.
* Have transparent pricing: our models are offered at the cost of the API + a 20% margin.
No surprises: no hidden limitations or unexpected account suspensions.
## Advanced Features. Professional Performance.
Tess operates with professional features that other platforms don't offer together:
* 250+ AI Models, including ChatGPT, Claude, Gemini, Grok, Sora, Nano Banana, Kling, VEO, ElevenLabs, and hundreds of others
* Professional tools for research, data analysis, document generation/editing, images, videos, etc.
* Agent Mode with autonomous multi-step execution (Agent Computer)
* Agent Studio to create custom agents without code
* External Agents to embed in websites and applications
* Complete API for custom integrations
* Parental Control — the first AI platform designed for families
* Memory Collections to organize contexts by project
* Deep Research with advanced search capabilities
* AI Computer (virtual machine for code execution and navigation)
See how to take your first steps using Tess.
Learn how to obtain professional results with Tess Agent Computer.
Learn about all the features and tools available in the chat.
Create your no-code agents in minutes, for any use case.
Discover the most important features of the platform.
Access our API documentation and use Endpoints to create your automations.
# YouTube
Source: https://docs.tess.im/en/youtube
The **YouTube** connector integrates Tess with YouTube. Once connected, the AI can help find videos and channel information and turn that context into useful summaries inside chats and agents.
YouTube is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Google account with access to the YouTube data you need.
* Permission to authorize YouTube-related OAuth scopes.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**. You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **YouTube** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **YouTube** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search videos and channels** relevant to a topic
* **Pull video metadata** such as titles, descriptions, and basic stats when available
* **Support content research** for marketing, education, and product teams
* **Summarize findings** into briefs or next-step recommendations
* **Keep research inside Tess** instead of switching tabs
## Example prompts
> 1. Find the 5 most relevant YouTube videos about AI agents for enterprise and summarize each one.
> 2. What are the latest uploads from our brand channel?
> 3. Create a short brief from videos about HubSpot automation for sales teams.
> 4. Compare the top results for 'Google Sheets automation' and list common tips.
## Best practices
* Be specific about topic, language, and freshness.
* Ask for sources/titles in the answer when you need to reuse the research.
* In agents, clarify whether YouTube is for research, channel monitoring, or content briefs.
## Troubleshooting
Reconnect with the Google account that owns or can access the needed YouTube data.
Reconnect YouTube in Connectors after credential or policy changes.
Some channel or private data may be unavailable depending on account permissions.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Deep Analysis
Source: https://docs.tess.im/untitled-page-13
### Secure Data Analysis with Deep Analysis
The Deep Analysis tool available in the chat and in agent creation was developed to enable analysis of large volumes of data without compromising security or accuracy.
* In the chat:
* In the Agent:
### How does Deep Analysis work?
When using Deep Analysis, the AI is connected to a secure virtual machine (Tess Computer) that uses Python libraries to perform complex calculations and data processing.
The AI acts as an interpreter after this processing, communicating the precise results to you, without "hallucinations", since the calculations are performed by a deterministic computational environment.
Guaranteed Privacy: You can drag spreadsheets and documents with sensitive data into the tool with the certainty that the information will remain secure and private, being used only for the requested analysis.
# Business Continuity
Source: https://docs.tess.im/Business-Continuity
Beyond preventing incidents, we prepare for recovery. Continuity combines backups, plans with clear recovery objectives, and exercises that test whether the team can execute what is written.
## Pillars
Critical systems have backups. We periodically validate restore capability — because a backup without a tested restore is only a hypothesis.
Continuity and disaster plans define how long we accept to return to operation and how much recent data loss is tolerable for essential components, guiding priorities in a crisis.
Periodic simulations and tests expose process gaps, forgotten dependencies, and role ambiguity — and produce concrete plan improvements.
## Service availability
We pursue high availability, with commercial targets of up to **99.9%** depending on the Enterprise contractual offer. Capacity and usage are monitored to absorb demand spikes without prolonged degradation.
## External dependencies
Cloud, payments, and AI model providers are treated as critical links in the chain. We assess risk, contracts, and security assurances from those partners — because Tess resilience also depends on them.
Continuity does not eliminate every outage; it reduces impact duration and makes recovery predictable and communicable.
## Related
* [Infrastructure](/Infrastructure)
* [Incident Response](/Incident-Response)
* [Responsibilities](/Responsibilities)
# Data Protection
Source: https://docs.tess.im/Data-Protection
**We handle content submitted to the platform (prompts, files, agent configuration) and usage records with controls that cover the full lifecycle:** collection needed for the service, protection, limited use, and disposal.
This page describes Tess AI Platform data-protection practices. For privacy and data-subject rights, see [Privacy](/Privacy).
## Protection controls
Communications between the customer’s browser/API and the platform use modern encryption. This prevents content from being read or altered by third parties while it travels over the public network.
Persisted data — including databases and files — remains encrypted in storage services. Even if the underlying media were accessed at the physical layer (cloud provider responsibility), content remains logically protected.
We distinguish categories such as identity, customer content, operational telemetry, and billing metadata. Each category has rules for who may access it, how long to retain it, and how to dispose of it.
Every read and write validates the organization/workspace context. An agent, file, or history is only available to people with permission in that account — there is no cross-customer “global view.”
Sensitive card data is handled by specialized payment processors. Tess keeps the subscription and billing references needed to operate the service and does not store the full card number.
We retain data for as long as needed for the contract, operations, and legal obligations. Deletion requests and data-subject rights are handled through official channels, within the perimeter Tess controls.
Your prompts and files do not train Tess’s models.
## Customer responsibility
The customer remains responsible for the lawful basis and appropriateness of content they submit to the platform (for example, third-party personal data in prompts or uploads).
## Next steps
* [Privacy](/Privacy)
* [Tess Commitments](/Tess-Commitments)
* [Responsibilities](/Responsibilities)
# Enterprise Contracts
Source: https://docs.tess.im/Enterprise-Contracts
### Our Model Integration Policy
A common question concerns the security of using the different Artificial Intelligence models available on Tess AI.
Our policy is clear: privacy is non-negotiable. The full data security and privacy that Tess offers is one of the main factors considered by our clients, especially enterprises.
* Certification and Security: We only integrate AI models into our platform that hold recognized security certifications, such as SOC 2, and that contractually guarantee data privacy.
* Additional Security: Using an AI model, such as DeepSeek, through Tess is safer than using it directly (in its free version). We ensure that the models run on our own infrastructure in a secure way, without sharing your data.
### Enterprise Contracts
For models from major providers, such as OpenAI's ChatGPT, we operate under enterprise-level agreements (Enterprise). This means your data is protected by the same security and confidentiality agreements that safeguard large global corporations. Any API integration is governed by these terms, ensuring that your information is not used for model training.
# Identity and Access
Source: https://docs.tess.im/Identity-Access
We govern identity on two layers: **the platform customers use**, and **Tess’s internal systems** used to operate the service. In both cases, we apply least privilege — access only to what is needed, for only as long as needed.
## On the platform (your organization)
* Workspace administrators invite users and assign roles (what each person can view, create, or administer).
* Enterprise plans can federate login to your company’s identity provider (SSO using industry standards), so authentication follows your corporate policy.
* Sharing of agents, pages, and integrations respects configured permissions — reducing privileges or removing a user cuts the corresponding access.
* **Tess does not manage day-to-day membership of your workspace:** who joins and who leaves is controlled by your organization’s administrators.
Role-based access control (RBAC) inside the workspace.
Available when contracted on the Enterprise plan.
Organization administrators control the user lifecycle.
## Inside Tess systems (internal operations)
* Employees receive access only after authorization; role changes and offboarding trigger credential review and removal.
* Critical systems require stronger authentication (including multi-factor).
* Highly privileged accounts are limited in number, inventoried, and reviewed periodically.
* Relevant administrative actions are logged for investigation and accountability.
Credentials, tokens, and Identity Provider security (when SSO is enabled) are a shared responsibility: **Tess protects the platform**; **the customer protects their own accounts and IdP.**
## Related
* [Responsibilities](/Responsibilities)
* [Operations and Detection](/Operations-Detection)
* [Tess Commitments](/Tess-Commitments)
# Incident Response
Source: https://docs.tess.im/Incident-Response
Security or availability incidents are not handled ad hoc. There is a program with roles, severity criteria, containment steps, and communication rules — practiced periodically.
## Response flow
Signals come from internal monitoring, automated alerts, or customer reports through official channels. Everything enters triage.
We classify impact and urgency: is there data exposure? How much of the service is affected? Who must be engaged now?
We limit the blast radius, remove the cause when possible, and restore operations safely — without shortcuts that reopen risk.
Affected parties are informed according to the nature of the event. Afterwards we record lessons and strengthen controls to reduce recurrence.
## When we involve the customer
Events with material impact on confidentiality, integrity, or availability of the service are communicated through appropriate channels. Relevant operational incidents also appear on the public System Status.
## How you help
Suspected unauthorized access, leaked credentials, or anomalous behavior in your account should be reported immediately to support: [support@tess.im](mailto:support@tess.im). The sooner Tess knows, the faster containment can happen in the right perimeter.
## Related
* [Operations and Detection](/Operations-Detection)
* [Business Continuity](/Business-Continuity)
* [Transparency](/Transparency)
# Infrastructure
Source: https://docs.tess.im/Infrastructure
Tess operates cloud-first: physical data-center controls belong to the cloud provider; Tess designs and operates the logical layer — networks, cloud identity, encryption, backups, and protection of internet-facing surfaces.
## Production environment
* Production workloads run in segregated networks, separated from non-production use.
* Ingress traffic goes through load balancing and service health checks.
* Network rules restrict which systems can communicate — especially administrative paths.
* Privileged infrastructure access is limited to authorized people and is logged.
## Edge and public surfaces
* DNS, content distribution, and edge protections help absorb abuse and volumetric attacks.
* Edge filtering reduces malicious traffic before it reaches the application.
* Sensitive public endpoints require encrypted communication.
* Physical controls (facility, power, hardware access) are the cloud provider’s responsibility, monitored by Tess through reports and contractual obligations.
## What this means for the customer
You do not need to operate Tess servers. Isolation between customers, encryption, and perimeter protection are part of the service. Your responsibility remains networks, devices, and identities in your own company when accessing the platform.
In audits, Tess describes and evidences the controls under its management and monitors the security assurances published by critical providers (cloud shared-responsibility model).
## Related
* [Data Protection](/Data-Protection)
* [Business Continuity](/Business-Continuity)
* [Responsibilities](/Responsibilities)
# Operations and Detection
Source: https://docs.tess.im/Operations-Detection
Preventive controls are not enough: we need to **see** what happens, **decide** what is abnormal, and **act**. Operations combine telemetry, security logging, vulnerability management, and review cycles.
## Capabilities
| Capability | What we do | Outcome for you |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| Observability | We track errors, latency, and application degradation signals; anomalies generate alerts for the responsible team. | Issues are detected early and handled before they become prolonged incidents. |
| Security logging | Authentication events, privileged actions, and relevant activity are available for investigation and support. | There is a factual basis to analyze unauthorized access or suspicious behavior. |
| Vulnerabilities | Components and surfaces are assessed on a defined cadence; findings are severity-ranked and tracked to remediation. | Known risks are not left open indefinitely — there is prioritization and a remediation timeline. |
| Availability | We monitor capacity and publish System Status when there is relevant operational impact. | You get visibility into outages and official communication during events. |
| Continuous improvement | Access reviews, risk assessments, and response/continuity exercises produce tracked action plans. | The security program evolves based on evidence, not only intent. |
## Related
* [Incident Response](/Incident-Response)
* [Secure Development](/SecureDevelopment)
* [Identity and Access](/Identity-Access)
# Privacy
Source: https://docs.tess.im/Privacy
Privacy is part of service design: we publish what we do, limit use to stated purposes, and provide clear paths to exercise rights — under LGPD and practices aligned with GDPR.
For technical protection controls (encryption, isolation, retention), see [Data Protection](/Data-Protection).
## Principles we follow
* **Transparency** via an accessible privacy notice and terms.
* **Minimization:** we collect what is needed for authentication, service delivery, billing, security, and support.
* **Purpose limitation:** we do not use customer content to train Tess’s own models.
* **Sharing with processors** (for example, AI models or payments) only to deliver the service, with appropriate contractual obligations.
## How to exercise rights and ask questions
| Need | Channel |
| ---------------------------------------- | ----------------------------------------- |
| Access, update, or delete personal data | [dpo@tess.im](mailto:dpo@tess.im) |
| Operational support and account security | [support@tess.im](mailto:support@tess.im) |
| Trust Center | [trust.tess.im](https://trust.tess.im) |
Cookies and similar technologies on the site/application are described in a specific policy. Use of agents, pages, and embeddings must respect the platform’s content and acceptable-use rules.
When a customer submits third-party personal data to the platform, they typically act as controller of that data — and need a lawful basis and internal guidance for doing so.
## Related
* [Data Protection](/Data-Protection)
* [Tess Commitments](/Tess-Commitments)
* [Transparency](/Transparency)
# Responsibilities
Source: https://docs.tess.im/Responsibilities
**Security in the cloud and on multi-tenant platforms:** responsibility is always shared. The table below makes explicit where Tess’s responsibility ends and the customer’s begins — avoiding ambiguous expectations in audits and day-to-day use.
## Shared model
| Topic | Tess responsibility | Customer responsibility |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| Infrastructure and platform | Hosting, encryption, isolation between organizations, monitoring, vulnerability management, and incident response in the Tess perimeter | Networks, devices, and security of the environment from which your users access the service |
| Workspace users | Provide roles, invites, and permission controls in the product | Invite, review, and remove users; apply least privilege inside your team |
| Authentication | Protect platform login; offer SSO/MFA according to the plan and available configuration | Protect passwords and tokens; secure your Identity Provider when corporate SSO is in use |
| Product configuration | Secure defaults and governance features (roles, sharing, execution audit) | Define roles, agent/page visibility, integrations, and internal usage policies |
| Content sent to AI | Process under contract, isolation, and privacy policy; do not train Tess’s own models with that content | Ensure lawful basis, internal classification, and appropriateness of prompts, uploads, and publications |
| Incidents | Investigate and respond in the Tess perimeter; communicate according to severity and obligation | Promptly notify suspicions involving accounts, credentials, or anomalous use in your organization |
## Related
* [Identity and Access](/Identity-Access)
* [Tess Commitments](/Tess-Commitments)
* [Incident Response](/Incident-Response)
* [Privacy](/Privacy)
# Secure Development
Source: https://docs.tess.im/SecureDevelopment
**The platform evolves continuously.** To keep security and stability intact, every relevant change follows a mandatory cycle of proposal, human review, automated validation, and authorized release.
## Change cycle
The change is described with its goal and expected impact — a fix, improvement, or new capability — before any deployment.
Another engineer reviews what will change. The goal is to catch logic errors, security risks, and side effects before the change moves forward.
Automated pipelines run tests and quality checks. Failures block the path until they are resolved.
Only changes that passed review and validation are deployed to the environment that serves customers. Changes outside this path do not reach production.
## Additional protections
Credentials, keys, and integration secrets are not embedded in source code. They are managed through separate mechanisms, with access limited to people and systems that truly need them.
Libraries and dependencies are monitored for known vulnerabilities. Findings are prioritized by severity and fixed according to internal remediation timelines — reducing inherited supply-chain risk.
This process exists so innovation and fixes can ship without giving up review, traceability, and barriers against unauthorized changes.
## Related
* [Operations and Detection](/Operations-Detection)
* [Infrastructure](/Infrastructure)
* [Tess Commitments](/Tess-Commitments)
# Tess Commitments
Source: https://docs.tess.im/Tess-Commitments
The commitments below are not just statements: each one is backed by operational practices, internal policies, and platform capabilities available to the customer.
## Commitments
**Customer data is protected in transit and at rest.** Access to sensitive information requires authentication and authorization; misuse is limited by access control and segregation between environments and organizations.
Prompts, files, memories, and responses generated through platform use are not used to train Tess’s own models. Processing happens to deliver the contracted service, under the privacy notice and terms of use.
Each workspace/organization operates in its own logical boundary. Users from one customer cannot access another customer’s data; roles and permissions limit what each person can see and run inside their own account.
Relevant interactions are recorded for governance and support — who ran what, in which organizational context, with which models, and with what consumption — enabling audit and investigation when needed.
We operate under LGPD and practices aligned with GDPR, with a DPO channel for data subjects to exercise rights of access, correction, and deletion, and for privacy questions: [dpo@tess.im](mailto:dpo@tess.im).
Security and compliance practices are communicated through the Trust Center, System Status, and public documentation — for due diligence and day-to-day follow-up.
## Vendors and AI model providers
**Tess is an orchestration layer:** it connects your organization to specialized models and services. That is why third-party risk is treated as a first-class control *(before contracting and throughout the relationship)*.
* We record who the vendor is, what data they may process, and who owns the relationship inside Tess.
* We assess security posture — audit reports, questionnaires, or equivalent evidence.
* When customer data is processed, we require contractual confidentiality and protection obligations.
* We send model providers only what is needed for the inference the user authorized at that moment.
* We track contractual data-use restrictions — including no-training commitments when they are part of the agreement.
* We monitor risk and performance; material vendor changes may require re-assessment.
**Typical partner categories:** cloud infrastructure, edge protection and content delivery, identity federation, payment processing, application monitoring, and AI model providers.
## Related
* [Data Protection](/Data-Protection)
* [Privacy](/Privacy)
* [Responsibilities](/Responsibilities)
* [Transparency](/Transparency)
# Transparency
Source: https://docs.tess.im/Transparency
Security and privacy are living programs. The channels below exist for due diligence, operational follow-up, and exercising rights — with responses in the right perimeter.
## Channels
Starting point for compliance materials, security practices, and documentation for customers and risk teams.
Operational questions, account access, anomalies, and assistance with secure use of the platform: [support@tess.im](mailto:support@tess.im)
Data-subject requests, personal-data processing questions, and LGPD/GDPR topics: [dpo@tess.im](mailto:dpo@tess.im)
## Compliance program
Controls aligned with **SOC 2** criteria for security, availability, and confidentiality, with continuous evidence management. Privacy is operated under LGPD and GDPR-aligned practices.
Security is sustained by engineering, infrastructure, security and compliance, privacy, support, and leadership — with defined roles, training, and accountability. Security is a continuous process, not a one-time checklist.
Ask, audit, and follow up — this section exists to make Tess’s “how” understandable and verifiable.
## Related
* [Tess Commitments](/Tess-Commitments)
* [Responsibilities](/Responsibilities)
* [Privacy](/Privacy)
* [Operations and Detection](/Operations-Detection)
# Advanced Settings
Source: https://docs.tess.im/en/advanced-settings
This is the advanced control of the agent's behavior. Here in the advanced settings is where you can pre-define the AI model, tools, temperature, and other parameters to ensure predictable responses aligned with your use case.
### **Where to find it?**
The Advanced Settings section is on the agent's settings screen and brings together the advanced configurations, where you pre-define:
* which LLM it should use (or whether it can use more than one)
* which tools (Tools) it should trigger as a rule
* which temperature range/response style will be used
Instead of relying solely on choices made in the chat and by the user, you define these parameters directly in the agent, within Agent Studio. They will only be changed if the agent is changed:
### **Why it matters**
Less creative and more analytical agents, for example in financial, legal, or compliance areas, need less "creativity" and more control.
You limit which tools the agent can call (e.g., allow or block Internet, integrations, etc.).
Everyone who uses that agent will have the same behavior, regardless of who is in the chat. A perfect feature for creating agents that will be used by many people.
### **What does it influence?**
If you choose a specific model for the agent's operation, the end user won't be able to switch it, and all interaction will be done with that defined model. For this reason, we disable the user's choice and lock in this model.
This process can be done when a specific model has been identified as the best performer for the agent's activity, and to avoid changes and inconsistent deliveries, you can set it and everyone who uses the agent will also be interacting with the same model.
In general, temperature can influence the LLM's creativity. So if your agent leans more toward financial or legal use, for example, you can opt for a lower temperature, keeping creativity controlled.
If your agent leans toward a more creative bias, such as in marketing, brainstorming, or content areas, you can opt for a higher temperature, allowing more creative freedom from the LLMs.
If your agent is specific and exclusive for analyses, you can leave Deep Analysis active, for example. But remember, when you define a tool, no other will be activated during the conversation.
If the agent is for generating images and you've found that Nano Banana is the best at that function (based on tests and prompt specifications), by setting it as the default, every time an image is generated it will use Nano Banana.
You can combine all three settings, or choose just one to standardize!
If it's an agent for your team, remember to document internally the explanations of these settings so the team understands the reasoning.
# Agent Monetization
Source: https://docs.tess.im/en/agent-monetization
Tess AI has the largest marketplace of agent creators in the world, allowing its users to monetize their agents and generate revenue from it. This article presents the different ways to generate revenue on the platform.
### **Ways to Monetize Your Creations**
There are three main ways to generate revenue with your content on Tess AI. You can combine them to maximize your earning potential.
\
You can create and sell custom AI agents to other users on the platform (one-time sale). When purchasing your agent, the user acquires the right to clone the model and use the prompt you developed.
How to set up an agent for sale:
* Access the Agent Studio and create a new agent.
* After finishing the configuration and training, save the agent and return to the main Studio screen.
* Make sure your agent status is set to "Published".
* Hover over the agent card and click the pencil icon to edit the information. Fill in the description fields, add relevant categories, and a cover image
* On the same screen, set the sale price for your template.
**Tip**
To increase the attractiveness of your agents, create solutions that meet common needs and routines of a large number of people. Well-structured templates with clear practical utility have greater sales potential.
\
In addition to the one-time sale, you can be paid systematically each time a user executes one of your agents, even if they have not purchased it.
To enable this option, go to the same agent editing screen and enable the option "Earn on each execution ('run')". Then, you must configure a markup, that is, a multiplier that will be applied to the base credit cost of the execution.
It is important to find a balance: a higher multiplier increases your earnings per execution, but also raises the cost for the end user. Test different values to find the ideal point that maximizes your return without discouraging usage.
\
You can also offer subscriptions for your Workspace and turn your profile into a source of recurring revenue. Users who subscribe to your Workspace will have access to the prompts of all agents you create from the moment of subscription.
A well-organized Workspace, with a clear visual identity and valuable content, is essential to attract and retain subscribers.
### **Strategies to Maximize Your Earnings**
* Maintain a professional profile: A complete and updated profile conveys credibility.
* Create valuable content: Publish agents and insights regularly to keep your audience engaged.
* Increase your visibility: Make some agents publicly available for free so more users can get to know your work.
* Use keywords: Optimize your agent descriptions with relevant terms so they can be easily found in the platform search.
Tess AI offers a complete dashboard so you can closely track the performance of your monetization strategies. Knowing how and where to view your earnings is essential to understand your performance and plan your next steps.
To view your financial information on the platform, the path is simple and quick. Learn more in this article here ([link](https://docs.tess.im/en/monetization)).
*With dedication and strategy, Tess AI can become an important source of income, rewarding your talent and creativity.*
# Get Agent Response
Source: https://docs.tess.im/en/agent-response
GET https://api.tess.im/agent-responses/{id}
Retrieve a specific agent response by its ID.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agent-responses/{id}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agent-responses/{id}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agent-responses/{id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agent-responses/{id}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agent-responses/{id}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agent-responses/{id}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agent-responses/{id}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agent-responses/{id}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the agent response
### **Response**
```json theme={null}
{
"id": 4773337,
"status": "succeeded",
"input": "hello",
"output": "Hello! If you have any questions about the Tess AI documentation, feel free to ask!",
"credits": 0.006145,
"root_id": 4773337,
"created_at": "2025-01-05T19:35:21.000000Z",
"updated_at": "2025-01-05T19:35:23.000000Z",
"template_id": 8794
}
```
# Agent Versioning
Source: https://docs.tess.im/en/agent-versioning
Version history, diff, and rollback in Agent Studio — how to use, cases, and permissions.
**Agent versioning** records an immutable history of the changes made in Agent Studio. With this, teams can **audit changes**, **compare versions (diff)**, and perform a **rollback** (restore previous versions) safely, maintaining complete traceability of what was published.
Versioning allows you to track an agent's evolution over time. With every relevant change, Tess automatically saves a new version, making it possible to review what changed, identify problems, and quickly revert to a stable state.
### What is it?
Every time you save an agent with relevant changes, Tess creates a new version — also called a **snapshot** (it is basically a "frozen" record of the agent's complete state at that moment).
This snapshot includes information such as Prompt, selected model, defined Tools, fields, and additional settings, as well as type and visibility, as applicable to the created agent.
The history is available when accessing an agent's editing in Agent Studio, opening a **versions panel** in a timeline format, featuring a summary of changes and a **before and after** (diff) comparison between versions.
### **Where to find it in the interface**
Follow the step-by-step below to reach the history from scratch:
In the left side menu, click on **Agent Studio**. In the agent list, click on the agent you want to audit to open it in the editor.
If you don't see **Agent Studio** in the menu, your profile probably doesn't have agent editing permissions in the Workspace.
With the agent open, look at the **top right corner** of the editor. Next to the **Preview** and **Save** buttons, there is a small **clock icon** — this is the **View history** button.
If the icon **doesn't appear**, check two things:
1. Does your profile have **read** permission for versions? (see [Permissions](#permissoes))
2. Does the agent already have at least **one registered version**? For very new agents, the icon only appears after the first version is created (save an actual change and reload).
By clicking the **clock icon**, the **Version history** panel opens over the editor. It shows:
* On the **left**: the **timeline** with all versions (the most recent marked as **Current**), with author and date/time.
* On the **right**: the **details** of the selected version, with collapsed sections (**No Changes**) and expanded sections with a **Changed** badge.
* In each changed section: a **BEFORE** block (red) and **AFTER** (green) — the diff of what changed.
Click on any item in the **timeline** on the left to see the diff of that version compared to the previous one. If your profile has **write** permission for versions, the action to **restore** that version will appear (the restoration is confirmed before applying and generates a new entry in the history). To close, use the **Close** button on the panel.
The **first version** is usually created after the first relevant edit post-availability of the feature for the Workspace. Very old agents may receive the initial version on the first save that generates a real change compared to the previous state.
### **What you see in each version**
* **Version number** and date/time the snapshot was recorded.
* **Author** of the change that originated that version (when applicable).
* **Change summary** (`change_summary`) in readable language, aligned with the diff between the version and the previous one.
* **Field-by-field diff** between the selected version and the immediately previous version, for fine review of the Prompt, model, Tools, and other fields exposed in the panel contract.
### Understanding the terms
1. **Snapshot**
A **snapshot** is a complete record of the agent at a point in time. It ensures that you can reconstruct exactly how the agent was configured.
2. **Diff**
The **diff** is the comparison between two versions. It allows you to quickly identify changes in a Prompt, Tools, or settings without having to review everything manually.
3. **Rollback**
A **rollback** does not "delete" the history: it **creates a new version** whose content restores the snapshot of a chosen version. Thus, the timeline remains **auditable** — it is clear that a restoration occurred and from which point.
Before confirming, the interface requests **explicit confirmation**, since the operation alters the agent's current state to reflect the selected version (as a new revision).
**Attention:** rollback is a **governance** action. Use it in accordance with your Workspace policies (changes in critical agents should be communicated to the team consuming the agent via chat, API, embed, or schedules).
***
## Use cases
A change in the Prompt or Tools broke behavior in production. The team restores the last stable version from the history, without manually rebuilding the agent.
It is necessary to demonstrate **what changed**, **who changed it**, and **when**, for internal reviews or enterprise requirements (e.g., SOX, ISO). The history centralizes snapshots and diffs.
The team tests a new configuration; if the result is not satisfactory, they rollback to the previous baseline, keeping a record of the attempts in the timeline.
Support or an Owner investigates an incident related to the agent's behavior: they compare versions before/after the incident to isolate the change that caused the undesired effect.
***
### Permissions
Access to versioning is controlled by **Workspace permissions** (RBAC) and, when applicable, by the plan's **feature flags**. In practical terms:
| Capability | Who usually has access |
| :-------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **View the history panel** and open diff between versions | Members with **read version history** permission for the agent (in the product, associated with the version viewing feature / `agent:version:read` as configured in the Workspace). |
| **Execute rollback** (restore a previous version) | Users with **write versions** permission — that is, authorized to create a new version from an old snapshot (equivalent to rollback permission / `AGENT_VERSION_WRITE` in the API layer). |
| **No read permission** | The icon or the history panel **does not appear** or access is denied, aligned with the Workspace policy (even if the user edits other aspects of the agent, according to other permissions). |
Roles like **Owner** and **Admin** of the Workspace usually include these capabilities when the feature is enabled for the plan. In **Enterprise** environments, governance can **delegate** reading or writing of versions to specific profiles (compliance, support) without granting full Owner access — according to the permissions matrix defined for the Workspace.
### **Relationship with visibility and governance**
* Versioning deals with the agent's **configuration history** ("how it was saved over time").
* [**Visibility**](/pt/visibility) defines who can **find or use** the agent (private, Workspace, public, etc.). Both complement each other in enterprise scenarios: you can restrict who sees the history even if the agent is shared in the Workspace.
***
## Limitations and roadmap (product vision)
* The current flow focuses on **snapshot on save** and **history + rollback** in Agent Studio. An explicit **draft / publish** flow with a dedicated button may evolve in future iterations.
* In some scenarios, **executions** (chat, API, scheduler, embed) may remain aligned with the **active agent** model as already known by the platform; isolating executions by "published version" is a product evolution when applicable.
**Best practices**
* Communicate relevant changes to the team before restoring agents used by many people.
* Use the diff (clock) to review changes in **Prompt** and **Tools** before triggering mass restorations.
* Combine with [**Members and Permissions**](/pt/members-permissions) policies to define who can alter critical agents.
Versioning brings operational security to evolve agents in Tess AI. With a complete history, visual diff, and simple rollback, your team can iterate with confidence, reduce risks, and maintain governance over agents in production.
# Knowledge Base
Source: https://docs.tess.im/en/agents/kb
Connect your agent to its own content library so that it is trained and responds based on specific materials — FAQs, policies, tutorials, and documents.
### **What is it?**
The agent's Knowledge Base is the set of documents, files, and texts that Tess adds to the systematic memory (system prompt) of that specific agent, being applied and considered in every execution of the agent.
You can add up to 30 items per agent, such as: articles, PDFs and manuals, internal policies, tutorials, playbooks, and spreadsheets. With file sizes up to 200MB each.
These contents are used by the agent to help analyze questions and generate responses, together with the prompt and other settings.
### **Why is it important?**
The agent always responds in line with the official documentation. This means less "guesswork", which reduces hallucinations and out-of-context responses. It is also essential for the agent to draw inspiration from existing templates when generating its output.
Each agent can have a different base added (Support, Finance, Onboarding, etc.), reflecting the content of its training. It is also simple to update — just replace a file or text in the Knowledge Base and the agent is updated.
### **How does it work in practice?**
When the user asks a question, the agent:
* Analyzes the question.
* Searches the agent's Knowledge Base for relevant excerpts.
* Uses those excerpts as context to generate the response.
* If the question is not related to what is in the base, the agent can follow the general prompt or the policies you defined.
### **How to add a base to an agent?**
Go to the Agents area and choose the desired agent (either a new one or an existing one)
Click on the Knowledge Base button and choose the files
Or drag directly from your computer
**Best practices**
* Start with the most frequently asked questions (support FAQ, finance, onboarding).
* Prefer content that is clear, objective, and well organized.
* Update the Knowledge Base whenever there is a policy or process change.
* Use different bases for agents with different functions (e.g.: one agent just for finance, another just for technical support).
# How It Works: AI Steps
Source: https://docs.tess.im/en/ai-steps
When building an agent in Tess AI’s AI Studio, you can go far beyond simple training. With Advanced Steps, you can create agents that run preliminary tasks, process information from multiple sources before starting the conversation (chat agent) or delivering the final result (text agent).
AI Steps work as mandatory execution stages every time the agent is triggered. Although optional, AI Steps can, when needed, make your agent’s architecture more sophisticated and increase its operational power. But keep in mind that AI Steps won’t always be necessary.
### **When is a Prompt alone not enough in the agent?**
Imagine you want to create an agent and automate generating a product description. All information about that product is in a PDF catalog.
If you only provide the PDF file to the agent as user input, it won’t know what to do. The AI needs an instruction to first read and interpret the contents of that file. A preliminary and mandatory stage in the overall agent structure. That’s exactly what Advanced Steps are for: they give your agent the ability to perform preliminary actions to complement the context your training needs.
### **Examples of Available Advanced Steps**
You can equip your agent with a variety of “senses” and abilities, including:
Allows the agent to read and extract all text from a PDF document.
A powerful ability to extract text that is inside images (like in a scanned flyer or a screenshot).
Optimizes the process by allowing you to instruct the agent to focus only on the relevant pages of a long document.
Turns your agent into an “internet reader,” capable of extracting information from web pages, such as the content of an article or data from an e-commerce site.
Allows the agent to run a Google search and use the results as the basis for its response.
### **How It Works in Practice: The Sequence of Actions**
When you configure an Advanced Step, you are defining an assembly line for your agent:
When needed, the user provides the initial material (e.g., a PDF file, a website URL).
The agent performs the action you configured (e.g., extracts text from the PDF, runs web scraping on the URL).
The step result (the extracted text, the website content, in this specific case) is automatically provided as context information to the AI prompt in the variable space.
The AI, now with the received information, runs your main prompt (e.g., "Create a product description based on the extracted text") and delivers the result.
### **Key Points for Effective Use**
Remember that each Step is an additional task in your agent’s workflow. This can increase processing time a bit to start the conversation (chat agent) or to deliver the final result (text agent). So use them strategically, only when they are truly necessary.
Since a step’s main goal is to complement training with advanced tasks and resources, it will run at the start of a chat or text-agent processing, as a preliminary stage.
> Example:
>
> We know there is an agent that creates events in the Google Calendar schedule. This step is not triggered throughout a conversation in the chat, for example; it runs at the beginning, right after the user completes the required inputs.
>
> So if I needed to create an agent that created events on my calendar, I would need to:
>
> * Include a step to fetch calendar information (App Integration)
> * Run an AI assistant that checks available slots and sets the new time
> * Collect the required information via inputs to create an event
> * Use the event creation step
>
> In other words, before chatting, all of this would need to happen.
It’s not enough to just add an Advanced Step; you need to instruct the AI in your prompt on how to use the information it provides. In other words: bring the parameter created for the Step into your prompt and place it in the appropriate location within the prompt structure.
Example: If you added a "PDF text extraction" step, your main prompt should include something like:
“Based on the text extracted from the document, identify the product’s main benefits and write three paragraphs about them: *pdf-text*”
This instruction connects the step action with the LLM’s reasoning, ensuring the collected information is used effectively.
# Max Mode
Source: https://docs.tess.im/en/api-max-mode
Our feature for activating the largest available context windows, which results in slower performance and higher costs
Normally, Tess uses a context window of 32k tokens (\~24,000 words). Max Mode allows you to enable the largest available context windows for all supported models. This is especially useful for long chats and for models that support extended context, such as 200k tokens on Claude models or 1M tokens on GPT-4.1 and Gemini 2.5 Pro.
MAX Mode pricing is calculated based on tokens, based on the model provider’s API price.
Note that using Max Mode may be slower and more expensive.
# Model slugs
Source: https://docs.tess.im/en/api-model-slugs
Technical identifiers for AI models in the Tess API (OpenAI-compatible model field and related configuration).
# Model slugs
> Use the **API Slug** — not the display name — whenever you select a model programmatically.
In Tess, every AI model has:
* a **display name** (what you see in the UI, e.g. `Claude 4.5 Haiku`)
* an **API Slug** (the stable technical id, e.g. `claude-4.5-haiku`)
APIs and JSON configs expect the slug.
## Where slugs appear in the API
The most common place is the OpenAI-compatible Chat Completions endpoint. Pass the slug in the `model` field:
```bash theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{id}/openai/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"model": "tess-5",
"messages": [{ "role": "user", "content": "hello!" }],
"stream": true
}'
```
See [Execute OpenAI Compatible](/en/open-ai-compat) for parameters and SDK examples.
The slug must be available for the **target agent** (its configured model list). An unknown or unavailable slug is rejected or ignored depending on the endpoint.
## Full slug catalog
For the complete list of models with costs **and** API Slugs, use:
* [Models and Costs](/en/models-and-cost) — authoritative table (text, image, video, and more)
## Cowork / Digital Employees
When importing a Digital Employee pack (JSON), the same slug goes in `model_override`. Guide and examples:
* [Model slugs (Cowork)](/en/cowork/digital-employees/configuracao-detalhada/model-slugs)
## Example slugs
| Display name | API Slug |
| ---------------- | ------------------ |
| Tess 5 | `tess-5` |
| Claude 4.5 Haiku | `claude-4.5-haiku` |
| ChatGPT 5.4 | `gpt-5.4` |
| ChatGPT 5.4 Mini | `gpt-5.4-mini` |
Prefer the [Models and Costs](/en/models-and-cost) table for the up-to-date catalog.
# Overview
Source: https://docs.tess.im/en/api-overview
Welcome to the Tess AI API documentation! This guide will help you get started with our API and understand how to integrate Tess AI's powerful capabilities into your applications.
### **Base URL**
All API requests should be made to the following base URL:
```text theme={null}
https://api.tess.im
```
## **Authentication**
All API requests require authentication using an API key. You can obtain your API key from the [Tess AI Dashboard](https://tess.im/dashboard).
To authenticate your requests, include your API key in the `Authorization` header:
```text theme={null}
Authorization: Bearer YOUR_API_KEY
```
## **Workspace header**
Authenticated API requests must include the workspace context header:
```text theme={null}
x-workspace-id: YOUR_WORKSPACE_ID
```
**Required as of 2026-09-01** for agent execution and other authenticated API endpoints. Until then, if omitted, the API falls back to the user's selected workspace (deprecated). After the cutoff, a missing header returns **422**. See [Errors](/en/errors).
## **API Endpoints**
The Tess AI API provides the following main categories of endpoints:
#### **Agents**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :---------------------- | :--------- | :--------------------------- | :----------------------------------------------------------- |
| `/agents` | GET | List all agents | [List Agents](https://docs.tess.im/en/list-agents) |
| `/agents/{id}` | GET | Get a specific agent | [Get Agent](https://docs.tess.im/en/get-agent) |
| `/agents/{id}/execute` | POST | Execute an agent | [Execute Agent](https://docs.tess.im/en/execute-agent) |
| `/agent-responses/{id}` | GET | Get agent execution response | [Get Agent Response](https://docs.tess.im/en/agent-response) |
#### **Agent Files**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :--------------------------------- | :--------- | :------------------ | :------------------------------------------------------------- |
| `/agents/{agentId}/files` | GET | List agent files | [List Agent Files](https://docs.tess.im/en/list-agent-files) |
| `/agents/{agentId}/files` | POST | Link files to agent | [Link Files to Agent](https://docs.tess.im/en/link-files) |
| `/agents/{agentId}/files/{fileId}` | DELETE | Delete agent file | [Delete Agent File](https://docs.tess.im/en/delete-agent-file) |
#### **Agent Webhooks**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :---------------------- | :--------- | :------------------- | :------------------------------------------------------------------- |
| `/agents/{id}/webhooks` | GET | List agent webhooks | [List Agent Webhooks](https://docs.tess.im/en/list-agent-webhooks) |
| `/agents/{id}/webhooks` | POST | Create agent webhook | [Create Agent Webhook](https://docs.tess.im/en/create-agent-webhook) |
#### **Workspaces**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :------------------ | :--------- | :----------------------------------- | :--------------------------------------------------------- |
| `/workspaces/usage` | GET | List agent execution history (usage) | [Workspace usage](https://docs.tess.im/en/workspace-usage) |
#### **Audit Events**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :-------------- | :--------- | :---------------------------------------------------- | :--------------------------------------------------- |
| `/audit-events` | GET | Pull workspace-scoped audit events for SIEM ingestion | [Audit events](https://docs.tess.im/en/audit-events) |
#### **Memories**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :--------------------- | :--------- | :---------------- | :----------------------------------------------------- |
| `/memories` | GET | List all memories | [List Memories](https://docs.tess.im/en/list-memories) |
| `/memories` | POST | Create a memory | [Create Memory](https://docs.tess.im/en/create-memory) |
| `/memories/{memoryId}` | PATCH | Update a memory | [Update Memory](https://docs.tess.im/en/update-memory) |
| `/memories/{memoryId}` | DELETE | Delete a memory | [Delete Memory](https://docs.tess.im/en/delete-memory) |
#### **Memory Collections**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :------------------------------------ | :--------- | :------------------- | :------------------------------------------------------------- |
| `/memory-collections` | GET | List all collections | [List Collections](https://docs.tess.im/en/list-collections) |
| `/memory-collections` | POST | Create a collection | [Create Collection](https://docs.tess.im/en/create-collection) |
| `/memory-collections/{collection_id}` | PUT | Update a collection | [Update Collection](https://docs.tess.im/en/update-collection) |
| `/memory-collections/{collection_id}` | DELETE | Delete a collection | [Delete Collection](https://docs.tess.im/en/delete-collection) |
#### **Files**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :------------------------ | :--------- | :--------------- | :--------------------------------------------------- |
| `/files` | GET | List all files | [List Files](https://docs.tess.im/en/list-files) |
| `/files` | POST | Upload a file | [Upload File](https://docs.tess.im/en/upload-file) |
| `/files/{fileId}` | GET | Get file details | [Get File](https://docs.tess.im/en/get-file) |
| `/files/{fileId}` | DELETE | Delete a file | [Delete File](https://docs.tess.im/en/delete-file) |
| `/files/{fileId}/process` | POST | Process a file | [Process File](https://docs.tess.im/en/process-file) |
#### **Webhooks**
| **Endpoint** | **Method** | **Description** | **Documentation** |
| :--------------- | :--------- | :---------------- | :------------------------------------------------------- |
| `/webhooks` | GET | List all webhooks | [List Webhooks](https://docs.tess.im/en/list-webhooks) |
| `/webhooks/{id}` | DELETE | Delete a webhook | [Delete Webhook](https://docs.tess.im/en/delete-webhook) |
## **Request Format**
Most API endpoints accept JSON-encoded request bodies. Make sure to include the following header in your requests:
```text theme={null}
Content-Type: application/json
```
## **Response Format**
All API responses are returned in JSON format. A successful response will typically have a `2xx` HTTP status code and contain the requested data. Error responses will have a `4xx` or `5xx` status code and include an error message.
# Quickstart
Source: https://docs.tess.im/en/api-quickstart
Get up and running with the Tess AI API in a few minutes.
## **Create an API Key**
To use the Tess AI API, you'll need an API key. You can create one by:
1. Going directly to [#Tess AI → User Tokens](https://tess.im/dashboard/user/tokens)
2. Or navigating through the UI:
* Visit [#Tess AI](https://tess.im/)
* Click on the User Menu
* Select "API Tokens"
* Click "Add New Token"
## **Set up your API Key (recommended)**
Configure your API key as an environment variable. This approach streamlines your API usage by eliminating the need to include your API key in each request. Moreover, it enhances security by minimizing the risk of inadvertently including your API key in your codebase.
## **Required headers**
Every authenticated API call needs:
```bash theme={null}
Authorization: Bearer YOUR_API_KEY
x-workspace-id: YOUR_WORKSPACE_ID
```
`x-workspace-id` is **required as of 2026-09-01**. Until then, omitting it falls back to your selected workspace (deprecated). After the cutoff, missing header → **422**. See [API Overview](/en/api-overview) and [Errors](/en/errors).
Example:
```bash theme={null}
curl --request GET \
--url 'https://api.tess.im/agents' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
## **Next Steps**
Now that you've made your first API call, you can explore:
* [Execute an Agent](https://docs.tess.im/en/execute-agent)
* [Available Endpoints](https://docs.tess.im/en/api-overview)
* [Rate Limits](https://docs.tess.im/en/rate-limits)
* [Error Handling](https://docs.tess.im/en/errors)
* [Connect to Zapier, Make, WhatsApp, n8n](https://docs.tess.im/en/make)
# AI Step | App Integration
Source: https://docs.tess.im/en/app-integrations
Your agents in Tess can do much more than just process information — they can act. App Integration Steps (App Integration) are the feature that connects your agents to external systems, allowing them to perform tasks in the real world or collect information from other platforms.
This guide explains the logic behind this powerful block of steps, showing how you can give "arms and legs" to your agents so they become active participants in your workflows.
### **The Step Logic: Get Information vs. Execute Action**
To understand App Integration, it’s helpful to contrast it with other types of steps.
They are designed to COLLECT INFORMATION and bring it into the agent so it can analyze it.
They are designed to EXECUTE ACTIONS outside the agent, using the information it already has.
It’s the difference between an agent that reads a sales report and an agent that updates a customer’s status in your CRM.
### **How It Works in Practice**
Configuring an integration follows a simple logical flow in AI Studio:
* Add a Step: In your agent, add a new App Integration step.
* Choose the App and the Action: Select the app you want to connect (e.g., Google Calendar) and the specific action the agent should perform (e.g., "Create Event").
* Map the Information: Configure the action fields (such as "Event Title" or "Guest Email"), filling them with the corresponding variables from your User Inputs.
The crucial point is that the agent does not execute this action randomly. Your **prompt** serves as the brain of the operation, defining the rules for these steps to happen at the beginning of the chat (chat agent) or before the final result (text agent).
### **Quick Example: Qualification and Scheduling**
Imagine an automated win and scheduling process, where a customer lands in your internal communication platform (e.g., Slack), notifying the support team about the new sale. This will be a trigger to activate Tess and fill in the information in the Google Calendar step, with name, email, and demo details through the Integration Step.
The agent then takes the variables collected in Slack and uses them to fill in and execute the "Create Event" action in Google Calendar, sending the invite automatically.
In this case, the Slack message was the trigger, and the Integration Step was the action tool.
NOTE\
\
For all of this to happen, you’ll need to integrate this app with your access in Tess. This will be the security mechanism so the process can be carried out and the tool triggered.
### **Expanding the Possibilities**
The applications are vast and allow you to automate countless processes:
* Update a Google Sheets spreadsheet
* Collect information from Google or Meta campaigns
* Upload a file to Drive or Box
App Integration Steps transform your agent from an informational assistant into a proactive, functional member of your team.
By mastering the logic of connecting your agent’s intelligence with the tools that power your business, you can automate processes, increase efficiency, and create truly integrated solutions.
# Audit events
Source: https://docs.tess.im/en/audit-events
GET https://api.tess.im/audit-events
A real-time enterprise event stream of AI execution and workspace activity for governance, observability, FinOps, analytics, compliance, and security.
Audit Events is the enterprise event stream for Tess AI. It exposes a normalized, real-time export of AI execution and workspace activity that any enterprise platform can consume — SIEM, data lakes, governance tools, FinOps platforms, analytics pipelines, and custom workflows.
Because Tess is the orchestration layer that sits in front of every model provider, this stream carries context that individual providers cannot see on their own: which workspace and user triggered the activity, which agent execution or tool call it belongs to, which model and provider served it, how long it took, which policies were enforced, and how much of the workspace's credit balance it consumed. That makes the stream valuable well beyond auditing — it is a foundation for enterprise observability, cost management, and analytics.
Audit Events is available only on **Enterprise plans**. Your workspace must have the audit events feature enabled, and your API token must be allowed to read audit events for the selected workspace.
## What you can build
A single stream powers many enterprise use cases:
* **Security monitoring** — forward events to your SIEM and alert on high-risk activity.
* **Compliance and audit** — retain an immutable record of who did what, when, and to which entity.
* **AI governance** — feed governance platforms that track model usage and policy enforcement across executions.
* **AI FinOps and cost analytics** — attribute credit consumption and usage volume by workspace, user, model, and provider.
* **Chargeback and showback** — bill or report credit consumption back to the teams that generate it.
* **Usage analytics** — understand adoption and execution volume by agent and model.
* **Operational monitoring** — track latency, failures, and tool-call behavior across executions.
* **Data lake ingestion** — land raw events in your warehouse for long-term analysis.
* **Custom enterprise workflows** — trigger downstream automation from any event type.
## Supported consumers
The endpoint is a generic export, not a security-only webhook. Common destinations include:
| Category | Examples |
| ------------------------- | --------------------------------------------------------- |
| SIEM | Splunk, Microsoft Sentinel, IBM QRadar |
| Data lakes and warehouses | Databricks, Snowflake, BigQuery |
| Governance platforms | Microsoft Purview, Collibra, BigID, Immuta |
| Streaming and messaging | Apache Kafka, Azure Event Hub, Google Pub/Sub |
| Object storage | Amazon S3, Azure Blob Storage, Google Cloud Storage (GCS) |
| FinOps and analytics | Cost analytics platforms, internal analytics pipelines |
| Custom | Any HTTPS webhook or collector |
## Architecture
Tess emits a single enterprise event stream over HTTPS that fans out to whatever platforms your organization runs.
```text theme={null}
TESS
Enterprise Event Stream
│
HTTPS / Webhook
┌─────────────┬───┴────────┬──────────────┐
│ │ │ │
SIEM Data Lake Governance AI FinOps
│ │ │ │
Splunk Databricks MS Purview Cost per team
Sentinel Snowflake Collibra Chargeback
QRadar BigQuery BigID Showback
```
## Endpoint
```http theme={null}
GET https://api.tess.im/audit-events
```
Send every request with:
* `Authorization: Bearer YOUR_API_KEY`
* `Accept: application/json`
* `x-workspace-id: YOUR_WORKSPACE_ID`
The response is always scoped to the workspace in `x-workspace-id`. Events that do not belong cleanly to one workspace are not emitted in this feed.
## Example request
```bash theme={null}
curl --request GET \
--url 'https://api.tess.im/audit-events?from=2026-04-08T00:00:00Z&to=2026-04-09T00:00:00Z&limit=100' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Accept: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
## Query parameters
Start of the audit window. Use an ISO-8601 timestamp.
End of the audit window. It must be greater than or equal to `from`. The time window cannot exceed 30 days.
Number of events to return. Default is `50`. Minimum is `1`; maximum is `200`.
Opaque cursor returned in `page.next_cursor`. Send it to continue reading from the previous page.
Filter by source. Supported values are `auditable` and `activity`.
Filter by normalized event type, such as `user_updated`, `workspace_created`, or `agent_execution_completed`.
Filter by actor user ID. Use `0` for system-generated events.
Filter by entity type, such as `user`, `workspace`, `agent_execution`, or `agent_message`.
Filter by entity ID.
Filter by risk level. Supported values are `low`, `medium`, `high`, and `critical`.
## Response
```json theme={null}
{
"data": [
{
"id": "activity:100001",
"occurred_at": "2026-04-08T10:00:00Z",
"workspace_id": 242,
"source": "activity",
"event_type": "agent_execution_completed",
"action": "completed",
"actor": {
"id": 16643,
"email": "user@example.com",
"type": "user",
"ip": null,
"user_agent": null
},
"entity": {
"type": "agent_execution",
"id": "183450",
"name": null
},
"changes": {
"before": {},
"after": {},
"changed_fields": []
},
"metadata": {
"workspace_id": 242,
"actor_user_id": 16643,
"status": "succeeded",
"duration_ms": 1200
},
"risk_level": "low",
"schema_version": 1
}
],
"page": {
"next_cursor": null,
"has_more": false
},
"meta": {
"workspace_id": 242,
"from": "2026-04-08T00:00:00Z",
"to": "2026-04-09T00:00:00Z",
"generated_at": "2026-04-09T00:00:02Z"
}
}
```
## Event schema
Each event uses the same normalized shape:
* `id`: Unique event ID with the source prefix, such as `activity:100001` or `auditable:9001`.
* `occurred_at`: UTC timestamp for the event.
* `workspace_id`: Workspace that owns the event.
* `source`: Event source category, currently `activity` or `auditable`.
* `event_type`: Normalized event name.
* `action`: Canonical action, such as `created`, `updated`, `completed`, `failed`, or `blocked`.
* `actor`: User or system principal that caused the event.
* `entity`: Object affected by the event.
* `changes`: Structured change details for the event, including previous values, new values, and the fields that changed when a diff is available.
* `metadata`: Additional context that helps classify, investigate, or correlate the event.
* `risk_level`: `low`, `medium`, `high`, or `critical`.
* `schema_version`: Version of the normalized event schema.
### Execution context in metadata
For AI execution events, `metadata` carries the orchestration context that only Tess can provide. Depending on the event type, it may include:
* Workspace and actor (user or system) identifiers
* The related entity, such as the agent execution or agent message
* Model and tool provider
* Latency (`duration_ms`)
* Tool call details (`tool_call_id`, `tool_name`, `tool_status`)
* Policy enforcement (`policy_name`, `policy_reason`, and whether the call was blocked)
* Credit consumption (`amount`, `credit_operation`, `credit_bucket`) for every credit increment, decrement, or loss
* Result status
This is what makes the stream useful for enterprise analytics and AI cost management, not just security auditing.
## AI FinOps
Because Tess orchestrates every AI execution, it can export usage signals that individual model providers cannot produce on their own. Use the stream to power AI FinOps initiatives:
* **Credit consumption per workspace and user** — every increment, decrement, and loss against a workspace's credit balance is an audited event carrying `amount`, `credit_operation`, and `credit_bucket`.
* **Usage volume by model and provider** — agent execution and tool-call events carry `model` and `tool_provider`, so you can break down execution volume by what your organization actually uses.
* **Chargeback and showback** — attribute credit consumption back to the workspace or user that generated it.
* **Operational cost signals** — `duration_ms` on executions and tool calls shows where latency, and therefore compute time, concentrates.
Land the stream in your warehouse (Snowflake, BigQuery, Databricks) or FinOps platform and aggregate on these `metadata` fields to build consumption dashboards per workspace, user, model, and provider.
## Consuming the stream
Use this endpoint as a pull source from any collector, pipeline, or platform.
Recommended setup:
1. Create an Enterprise API token dedicated to event ingestion.
2. Store the token in your platform's secret manager.
3. Poll `GET /audit-events` with a narrow time window, such as 5 or 15 minutes.
4. Keep the last successful `next_cursor` per workspace.
5. Preserve the original JSON payload at ingestion time.
6. Map fields such as `event_type`, `actor.id`, `entity.type`, `entity.id`, `risk_level`, and `workspace_id` to your platform's schema or custom properties.
7. Alert on, or aggregate, event types and `metadata` fields according to your use case.
Use `id` and `occurred_at` for deduplication and replay safety.
### Example: SIEM ingestion
For a SIEM such as Splunk, Microsoft Sentinel, or IBM QRadar, treat the endpoint as a pull-based JSON log source and alert on high-risk event types or `risk_level` values according to your security policy.
For IBM QRadar specifically, configure Tess AI as a custom JSON log source or route the API through an intermediate collector that forwards events to QRadar. Keep the normalized JSON intact and create custom properties for:
* `workspace_id`
* `source`
* `event_type`
* `action`
* `actor.id`
* `actor.type`
* `entity.type`
* `entity.id`
* `risk_level`
* `id`
* `schema_version`
## Pagination
Read events in ascending order by `occurred_at` and event ID.
If `page.has_more` is `true`, call the endpoint again with the same filters and the returned `page.next_cursor`.
```bash theme={null}
curl --request GET \
--url 'https://api.tess.im/audit-events?from=2026-04-08T00:00:00Z&to=2026-04-09T00:00:00Z&limit=100&cursor=NEXT_CURSOR' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Accept: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
## Errors
* `401` or `403`: Invalid token, missing Enterprise entitlement, missing audit events permission, or no access to the workspace.
* `422`: Missing or invalid parameters, missing `x-workspace-id`, invalid cursor, or a time window longer than 30 days.
* `429`: Rate limit exceeded.
* `503`: One of the audit event sources is temporarily unavailable. Retry the same request later.
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
# AI Step | BOX
Source: https://docs.tess.im/en/box
The Box step – Download File allows your agent to download files directly from Box via URL and use this content within the Tess flow. This turns the agent into an active consumer of external documents, enabling analyses, summaries, and automations based on files.
### **What is the Step?**
This step connects Tess to Box to download files from a shared URL.
In practice, it downloads the file from Box and injects the content into the agent’s context, also allowing the file to be used in:
* Other steps
* Agent responses
* Processing (summary, analysis, extraction, etc.)
### **Where to find it**
1. Go to AI Studio
2. Click Add AI Step
3. In Select Step Category, choose App Integration
4. In Choose an App, select Box
5. In Select Step Type, choose Download File
### How to use (Quickstart)
1. Add the step\
Choose App Integration → Box → Download File and define a name for the step. \
\
*Ex: Download contract, Download briefing, etc.*
2. Configure the file URL\
Here you have 3 options:\
\
2.1 Fixed URL (pre-configured): Paste the shared Box link directly. Ideal for standard files\
2.2 Via user input: Create an input field (short text) for the user to enter the URL and reference this variable in the URL field\
2.3 User Decision enabled: The agent will request the URL during execution. It works similarly to input, but is already enabled in the step as a required field.
3. Save the step
This step works as an external data ingestion point. With the step working, the content will already be available in the agent’s context.
Use the file in the next steps or in the response to complement the agent’s training.
Important notes:
* The Step does not analyze the file by itself
* It only brings the file into the context
\
The analysis happens afterward, via:
1. Agent Prompt
2. Other steps (e.g., text processing)
In other words:
Box (Download) → brings the data
Agent / other steps → use the data
### Practical Examples:
1. **Automatic contract analysis**
Prompt: "Based on the following contract, identify risk clauses, deadlines, and main obligations, and score them for the requester"
Here you can also include another File Processing Step or add assistants for analysis or the next action after download.
2. **Client briefing summary**
Prompt: "Summarize the briefing and highlight objectives, target audience, and deliverables."
Usage:
* Fixed URL or provided by the user
* Ideal for marketing teams
2. **Structured data extraction**
Important!
* Box must be integrated with your Tess account
* The step consumes credits (download + subsequent processing)
* The file enters the agent’s context window
* The step does not edit or send files, it only downloads
Box – Download File is the gateway to using external documents within Tess. With it, your agent no longer depends only on direct inputs and starts working with real files, opening space for more robust and intelligent automations.
# Code Generator
Source: https://docs.tess.im/en/code-gen
The world of programming is vast and, at times, challenging. With the goal of simplifying and accelerating your journey, Tess AI offers the Code Generator, a powerful tool integrated into our Agent Studio, designed to be your personal programming assistant.
This article will guide you through the features of the Code Generator, showing how to use it to develop, fix, and optimize your projects.
### **What is the Code Generator?**
The Code Generator is an interactive chat environment, powered by an Artificial Intelligence specialized in programming. Located in the Agent Studio tab under Code Generator, this generator is pre-trained to understand, generate, and debug code in virtually all existing programming languages.
Whether you’re an experienced developer looking to optimize your time or a beginner taking your first steps, this tool offers smart support to turn your ideas into working code.
**What can you do with the Code Generator?**
Describe what you need, and the AI will generate the initial code. For example: "Create a Python script that reads a CSV file and calculates the average of a specific column."
Found an error you can’t solve? Paste the problematic code snippet and ask the AI to identify and fix the issue.
Easily migrate a function or script from one language to another. For example, ask it to "translate this Java code to JavaScript."
Ask the AI to explain a concept, a function, or a complex block of code. It’s a great way to deepen your knowledge.
**Tips to Get the Best Results**
To make the most of the Code Generator’s potential, follow these best practices:
The clearer and more detailed your request is, the more accurate the generated code will be. Specify the language, the libraries you plan to use, and the final goal.
When asking to fix an error, include not only the code, but also the error message you’re getting.
The chat is a dynamic environment. Use it to refine the generated code. Ask it to add comments, simplify a function, or optimize performance.
# AI Step | CSV to Text
Source: https://docs.tess.im/en/csv-to-text
The CSV to Text step converts spreadsheet files (.csv) into structured, readable text for language models. With it, your agents can directly consume tabular data without needing spreadsheet software or manual file processing.
### What is the Step?
This step belongs to the Document Processing group — a category dedicated to transforming file formats into content usable by AI.
In practice, CSV to Text:
* Reads CSV files hosted online or uploaded by the user
* Automatically detects delimiters (comma, semicolon, etc.)
* Converts tabular content into plain, continuous text
* Injects this text into the agent’s context before the conversation starts
The output is a block of raw text, properly formatted to be used in prompts as a basis for analysis, report generation, or contextual responses.
### Where to find it
1. Go to AI Studio
2. Click on Add AI Step
3. In Select Step Category, choose Document Processing
4. Select CSV to Text
### How to use (Quickstart)
Configuration fields:
| Field | Required | Description |
| :---------- | :------- | :------------------------------------------------------------------------------------------------------------------------ |
| Step Name | Yes | Internal step name. Use only alphanumeric characters. This name is used to reference the result in other steps or prompts |
| File Upload | Yes | Direct URL of a CSV file hosted online or a user file input variable (e.g.: `{{csvfile}}`) |
The step acts as a bridge between tabular data and natural language.
CSV (URL or upload) → Step processes and converts
↓
Plain text enters the context → Agent uses the data to respond
About the output:
* The content is presented linearly — without visual table formatting
* The row and column structure is converted into a textual sequence
* It should be treated as raw data injected into the prompt
**Quality tip:**\
CSV files with a header row generate much more accurate context for the agent. Without headers, the model may struggle to identify what each column represents.
### Practical examples
**1. Campaign and lead analysis**
Prompt:\
"Analyze the lead spreadsheet data. Identify conversion patterns, compare performance by channel, and generate a weekly performance report with budget optimization suggestions."
Usage:
* Export CSV from CRM or traffic platform
* Host it online or use as User Input
* Step converts and agent analyzes automatically
**2. Automated candidate screening**
Prompt:\
"Evaluate the candidates listed in the file. Cross-reference skills and years of experience with the job requirements below and generate a ranking of the top 5 most suitable profiles with individual summaries."
Usage:
* CSV exported from a recruitment platform
* Agent processes and ranks without human intervention
**3. Churn and feedback monitoring**
Prompt:\
"Analyze customer satisfaction and usage data. Categorize main complaints, identify customers at high risk of churn, and suggest preventive actions for each profile."
Usage:
* CSV exported from CRM or survey tools
* Agent generates actionable insights for the retention team
**4. Operational data consolidation**
Prompt:\
"Read the spreadsheet data and create an executive summary with the main KPIs, deviations, and operational alerts for the period."
Usage:
* Operational reports in CSV format
* Ideal for Text Agents triggered automatically
**Best practices**
* Use files with headers: the first row with column names greatly improves agent accuracy
* Prefer clean and organized files: merged columns, special formatting, or inconsistent data reduce conversion quality
* Reference the step in the prompt: use the step name to tell the agent where the data is. Example: *"Use the data from step *`analise_leads`* to..."*
* Combine with other steps: CSV to Text → analysis → Google Sheets Write Values (to export results)
* Avoid very large files: spreadsheets with many columns and thousands of rows may exceed the agent’s context window
### Important notes
* The step runs before user interaction
* The file URL must be public and accessible
* The result is raw text, not a formatted table
* Analysis quality depends on the organization of the original file
CSV to Text is the gateway for structured data within Tess. It democratizes access to spreadsheets without requiring external tools, allowing any agent to read, interpret, and generate insights from tabular data in an autonomous and scalable way.
# Get Activity Log
Source: https://docs.tess.im/en/de-activity
GET https://api.tess.im/digital-employees/{employeeId}/activity
Returns the activity log for a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/123/activity?limit=50' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/123/activity',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
},
params: {
limit: 50
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/activity"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
params = {
"limit": 50
}
response = requests.get(url, headers=headers, params=params)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/activity?limit=50",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/activity?limit=50"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/123/activity?limit=50", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.GetAsync("https://api.tess.im/digital-employees/123/activity?limit=50");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/activity?limit=50')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee.
### **Query Parameters**
Maximum number of activity events to return. Default: 50. Max: 100.
### **Response**
```json theme={null}
{
"data": [
{
"id": 1,
"event": "run_completed",
"actor": { "id": 1, "name": "Alice" },
"metadata": {},
"created_at": "2026-06-24T17:31:00Z"
}
]
}
```
# Approve Hire Request
Source: https://docs.tess.im/en/de-approve
POST https://api.tess.im/digital-employees/{employeeId}/approve
Approves a digital employee that is in pending_approval status.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/approve' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/approve',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/approve"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/approve",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/approve"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/approve", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.PostAsync("https://api.tess.im/digital-employees/123/approve", null);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/approve')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee to approve.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"status": "active"
}
}
```
Only digital employees in `pending_approval` status can be approved. Attempting to approve an employee with a different status will return a `422` error.
# Upload Avatar
Source: https://docs.tess.im/en/de-avatar-upload
POST https://api.tess.im/digital-employees/avatar-upload
Uploads an avatar image for use with a digital employee.
This endpoint accepts `multipart/form-data`. The uploaded image will be processed and made available as an avatar URL and thumbnail URL.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/avatar-upload' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--form 'avatar=@/path/to/avatar.png' \
--form 'name=My Employee Avatar'
```
```json Node.js theme={null}
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const form = new FormData();
form.append('avatar', fs.createReadStream('/path/to/avatar.png'));
form.append('name', 'My Employee Avatar');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/avatar-upload',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
...form.getHeaders()
},
data: form
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/avatar-upload"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
with open("/path/to/avatar.png", "rb") as f:
files = {"avatar": f}
data = {"name": "My Employee Avatar"}
response = requests.post(url, headers=headers, files=files, data=data)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/avatar-upload",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => [
'avatar' => $cfile,
'name' => 'My Employee Avatar'
],
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.io.*;
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
String boundary = "----FormBoundary" + System.currentTimeMillis();
Path filePath = Path.of("/path/to/avatar.png");
byte[] fileBytes = Files.readAllBytes(filePath);
String body = "--" + boundary + "\r\n"
+ "Content-Disposition: form-data; name=\"avatar\"; filename=\"avatar.png\"\r\n"
+ "Content-Type: image/png\r\n\r\n";
byte[] bodyStart = body.getBytes();
String bodyEnd = "\r\n--" + boundary + "\r\n"
+ "Content-Disposition: form-data; name=\"name\"\r\n\r\n"
+ "My Employee Avatar\r\n"
+ "--" + boundary + "--\r\n";
byte[] bodyEndBytes = bodyEnd.getBytes();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(bodyStart);
baos.write(fileBytes);
baos.write(bodyEndBytes);
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/avatar-upload"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "multipart/form-data; boundary=" + boundary)
.POST(HttpRequest.BodyPublishers.ofByteArray(baos.toByteArray()))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
"path/filepath"
)
func main() {
var buf bytes.Buffer
writer := multipart.NewWriter(&buf)
file, _ := os.Open("/path/to/avatar.png")
defer file.Close()
part, _ := writer.CreateFormFile("avatar", filepath.Base("/path/to/avatar.png"))
io.Copy(part, file)
writer.WriteField("name", "My Employee Avatar")
writer.Close()
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/avatar-upload", &buf)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Set("Content-Type", writer.FormDataContentType())
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Net.Http.Headers;
using System.IO;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
using var form = new MultipartFormDataContent();
var fileBytes = await File.ReadAllBytesAsync("/path/to/avatar.png");
var fileContent = new ByteArrayContent(fileBytes);
fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/png");
form.Add(fileContent, "avatar", "avatar.png");
form.Add(new StringContent("My Employee Avatar"), "name");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/avatar-upload",
form);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/avatar-upload')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
form_data = [
['avatar', File.open('/path/to/avatar.png')],
['name', 'My Employee Avatar']
]
request.set_form(form_data, 'multipart/form-data')
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as a Bearer token on every request.
ID of the workspace. Required for all Digital Employees API requests.
### **Request Body**
Avatar image file. Maximum size: 5 MB. Accepted formats: JPEG, PNG, WebP.
Optional display name for the avatar. Maximum 255 characters.
### **Response**
```json theme={null}
{
"data": {
"id": 1,
"url": "https://cdn.tess.im/avatars/abc123.png",
"thumbnail_url": "https://cdn.tess.im/avatars/abc123_thumb.png"
}
}
```
# Get Capabilities
Source: https://docs.tess.im/en/de-capabilities
GET https://api.tess.im/digital-employees/capabilities
Returns the effective capability map for the current user in the workspace.
Use this endpoint to check which actions the current user can perform on Digital Employees before making write requests.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/capabilities' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/capabilities',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/capabilities"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/capabilities",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/capabilities"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/capabilities", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync("https://api.tess.im/digital-employees/capabilities");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/capabilities')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
The `Authorization` header must contain a valid Bearer token.
ID of the workspace to query capabilities for.
### **Response**
```json theme={null}
{
"data": {
"can_write": true,
"can_invoke": true,
"can_manage_state": true
},
"has_terminated_employees": false
}
```
#### Response fields
| Field | Type | Description |
| :------------------------- | :------ | :---------------------------------------------------------- |
| `data.can_write` | boolean | Whether the user can create or update employees. |
| `data.can_invoke` | boolean | Whether the user can trigger manual runs. |
| `data.can_manage_state` | boolean | Whether the user can pause, resume, or rollback employees. |
| `has_terminated_employees` | boolean | Whether any soft-deleted employees exist in this workspace. |
# Create Employee from Agent
Source: https://docs.tess.im/en/de-create-from-agent
POST https://api.tess.im/digital-employees/agents/{agentId}
Creates a new Digital Employee linked to an existing agent.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/agents/99' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--data '{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const agentId = 99;
const config = {
method: 'post',
url: `https://api.tess.im/digital-employees/agents/${agentId}`,
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
data: {
name: 'Finance Ops',
execution_mode: 'agent',
execution_approval_mode: 'autonomous',
heartbeat_cron: '0 9 * * 1-5',
execution_timezone: 'America/Sao_Paulo'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
agent_id = 99
url = f"https://api.tess.im/digital-employees/agents/{agent_id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
payload = {
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/agents/{$agentId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
"name" => "Finance Ops",
"execution_mode" => "agent",
"execution_approval_mode" => "autonomous",
"heartbeat_cron" => "0 9 * * 1-5",
"execution_timezone" => "America/Sao_Paulo"
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
int agentId = 99;
String body = """
{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/agents/" + agentId))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
agentId := 99
payload := strings.NewReader(`{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}`)
client := &http.Client{}
url := fmt.Sprintf("https://api.tess.im/digital-employees/agents/%d", agentId)
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
int agentId = 99;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var json = """
{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
""";
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(
$"https://api.tess.im/digital-employees/agents/{agentId}", content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
agent_id = 99
uri = URI("https://api.tess.im/digital-employees/agents/#{agent_id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request.body = {
name: 'Finance Ops',
execution_mode: 'agent',
execution_approval_mode: 'autonomous',
heartbeat_cron: '0 9 * * 1-5',
execution_timezone: 'America/Sao_Paulo'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header.
ID of the workspace.
### **Path Parameters**
ID of the existing agent to link the new Digital Employee to.
### **Request Body**
Employee name. Max 255 characters.
Execution mode. Values: `agent` (autonomous) or `chat`. Default: `agent`.
Whether runs require manual approval. Values: `autonomous` or `approval_required`.
Cron expression for scheduled runs (e.g. `0 9 * * 1-5`). Max 128 characters.
Schedule builder config (alternative to `heartbeat_cron`).
Timezone for schedule execution (e.g. `America/Sao_Paulo`). Max 64 characters.
Minimum seconds between runs. Either `0` (no limit) or `>= 60`.
Custom system prompt for this employee. Max 4096 characters.
Override the AI model (e.g. `tess-6`). Max 100 characters.
Override tool configuration. Max 255 characters.
Enable Search Intelligence for runs.
Array of connector identifiers to enable.
Array of skill identifiers to override.
Max consecutive run failures before auto-pause. Range: 1–100.
Execution priority order. Range: 0–999.
Whether the employee shares memory with its owner agent.
Avatar image URL. Max 2048 characters.
Thumbnail image URL. Max 2048 characters.
MBTI personality type (e.g. `INTJ`).
Wake policy configuration object.
Budget policy configuration object.
Goal configuration object.
Work policy configuration object.
Voice identifier for real-time voice mode.
### **Response**
```json theme={null}
{
"data": {
"id": 124,
"agent_id": 99
}
}
```
# Create Standalone Employee
Source: https://docs.tess.im/en/de-create-standalone
POST https://api.tess.im/digital-employees/standalone
Creates a new Digital Employee with a new host agent.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/standalone' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--data '{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/standalone',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
data: {
name: 'Finance Ops',
execution_mode: 'agent',
execution_approval_mode: 'autonomous',
heartbeat_cron: '0 9 * * 1-5',
execution_timezone: 'America/Sao_Paulo'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/standalone"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
payload = {
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/standalone",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
"name" => "Finance Ops",
"execution_mode" => "agent",
"execution_approval_mode" => "autonomous",
"heartbeat_cron" => "0 9 * * 1-5",
"execution_timezone" => "America/Sao_Paulo"
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String body = """
{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/standalone"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
payload := strings.NewReader(`{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}`)
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/standalone", payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var json = """
{
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
""";
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/standalone", content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/standalone')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request.body = {
name: 'Finance Ops',
execution_mode: 'agent',
execution_approval_mode: 'autonomous',
heartbeat_cron: '0 9 * * 1-5',
execution_timezone: 'America/Sao_Paulo'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header.
ID of the workspace.
### **Request Body**
Employee name. Max 255 characters.
Execution mode. Values: `agent` (autonomous) or `chat`. Default: `agent`.
Whether runs require manual approval. Values: `autonomous` or `approval_required`.
Cron expression for scheduled runs (e.g. `0 9 * * 1-5`). Max 128 characters.
Schedule builder config (alternative to `heartbeat_cron`).
Timezone for schedule execution (e.g. `America/Sao_Paulo`). Max 64 characters.
Minimum seconds between runs. Either `0` (no limit) or `>= 60`.
Custom system prompt for this employee. Max 4096 characters.
Override the AI model (e.g. `tess-6`). Max 100 characters.
Override tool configuration. Max 255 characters.
Enable Search Intelligence for runs.
Array of connector identifiers to enable.
Array of skill identifiers to override.
Max consecutive run failures before auto-pause. Range: 1–100.
Execution priority order. Range: 0–999.
Whether the employee shares memory with its owner agent.
Array of file IDs for the knowledge base. Max 20 entries.
Avatar image URL. Max 2048 characters.
Thumbnail image URL. Max 2048 characters.
MBTI personality type (e.g. `INTJ`).
Wake policy configuration object.
Budget policy configuration object.
Goal configuration object.
Work policy configuration object.
Voice identifier for real-time voice mode.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"workspace_id": 10
}
}
```
# Delete Digital Employee
Source: https://docs.tess.im/en/de-delete
DELETE https://api.tess.im/digital-employees/{employeeId}
Soft-deletes a digital employee. The employee can be recovered.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url 'https://api.tess.im/digital-employees/{employeeId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'delete',
url: 'https://api.tess.im/digital-employees/{employeeId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("DELETE", "https://api.tess.im/digital-employees/{employeeId}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.DeleteAsync(
"https://api.tess.im/digital-employees/{employeeId}"
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Authentication is performed via the `Authorization: Bearer YOUR_API_KEY` header.
ID of the workspace. Required for all Digital Employees API endpoints.
### **Path Parameters**
The ID of the digital employee to delete.
### **Response**
```json theme={null}
{
"message": "Digital employee deleted successfully."
}
```
This is a soft-delete operation. The employee data is retained and can be recovered by your workspace administrator.
# Detach Digital Employee
Source: https://docs.tess.im/en/de-detach
POST https://api.tess.im/digital-employees/{employeeId}/detach
Removes the parent relationship, making this employee a top-level employee.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/detach' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/detach',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/detach"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/detach",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/detach"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/detach", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/123/detach",
null
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/detach')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee to detach from its parent.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"parent_employee_id": null,
"workspace_id": 10
}
}
```
# Duplicate Digital Employee
Source: https://docs.tess.im/en/de-duplicate
POST https://api.tess.im/digital-employees/{employeeId}/duplicate
Creates a copy of an existing digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/{employeeId}/duplicate' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/{employeeId}/duplicate',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}/duplicate"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/duplicate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/duplicate"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/digital-employees/{employeeId}/duplicate", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/{employeeId}/duplicate",
null
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/duplicate')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Authentication is performed via the `Authorization: Bearer YOUR_API_KEY` header.
ID of the workspace. Required for all Digital Employees API endpoints.
### **Path Parameters**
The ID of the digital employee to duplicate.
### **Response**
```json theme={null}
{
"message": "Employee duplicated.",
"data": {
"id": 200
}
}
```
# Export Template Pack
Source: https://docs.tess.im/en/de-export-template
GET https://api.tess.im/digital-employees/template-packs/agents/{agentId}
Exports a digital employee configuration as a portable template pack.
Export a well-configured digital employee as a reusable template pack. The exported pack captures the employee's full configuration — tools, skills, prompts, scheduling, and policies — so it can be shared and imported into other agents or workspaces.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/template-packs/agents/99' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/template-packs/agents/99',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/template-packs/agents/99"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/template-packs/agents/99",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/template-packs/agents/99"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET",
"https://api.tess.im/digital-employees/template-packs/agents/99", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync(
"https://api.tess.im/digital-employees/template-packs/agents/99");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/template-packs/agents/99')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as a Bearer token on every request.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
ID of the agent to export as a template pack.
### **Response**
Returns the full template pack payload — an object containing the employee configuration, tools, skills, scheduling settings, policies, and metadata required to recreate the employee in another context.
```json theme={null}
{
"version": "1.0",
"employee": {
"name": "Finance Ops",
"execution_mode": "agent",
"execution_approval_mode": "autonomous",
"heartbeat_cron": "0 */2 * * *",
"system_prompt_override": "...",
"tools_override": "...",
"skills_override_json": [],
"goal_json": {},
"wake_policy_json": {},
"budget_policy_json": {}
}
}
```
Save the exported pack payload to pass it into [Preview Template Import](/en/de-preview-import) or [Import Template Pack](/en/de-import-template).
# Get Employee Files
Source: https://docs.tess.im/en/de-files
GET https://api.tess.im/digital-employees/{employeeId}/files
Returns the files associated with the most recent run of a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/123/files' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/123/files',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/files"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/files",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/files"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/123/files", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.GetAsync("https://api.tess.im/digital-employees/123/files");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee.
### **Response**
```json theme={null}
{
"data": {
"files": [],
"external_files": [],
"message_id": null
}
}
```
# Get Digital Employee
Source: https://docs.tess.im/en/de-get
GET https://api.tess.im/digital-employees/{employeeId}
Returns a single digital employee with its main relations.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/123' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const employeeId = 123;
const config = {
method: 'get',
url: `https://api.tess.im/digital-employees/${employeeId}`,
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
employee_id = 123
url = f"https://api.tess.im/digital-employees/{employee_id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{$employeeId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
int employeeId = 123;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/" + employeeId))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
employeeId := 123
client := &http.Client{}
url := fmt.Sprintf("https://api.tess.im/digital-employees/%d", employeeId)
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
int employeeId = 123;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync(
$"https://api.tess.im/digital-employees/{employeeId}");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
employee_id = 123
uri = URI("https://api.tess.im/digital-employees/#{employee_id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header.
ID of the workspace.
### **Path Parameters**
ID of the digital employee to retrieve.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"status": "idle",
"agent": {},
"owner": {},
"children": [],
"latest_run": null
}
}
```
Returns `404` if the employee does not exist or is not accessible in the given workspace.
# Get Run
Source: https://docs.tess.im/en/de-get-run
GET https://api.tess.im/digital-employees/{employeeId}/runs/{runId}
Returns the details of a specific run.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/runs/{runId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync(
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/runs/{runId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
**Authorization:** Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The ID of the digital employee.
The ID of the run to retrieve.
### **Response**
```json theme={null}
{
"data": {
"id": 501,
"digital_employee_id": 123,
"status": "completed",
"wake_reason": "manual",
"execution_id": 9001,
"started_at": "2026-06-24T17:30:00Z",
"finished_at": "2026-06-24T17:31:00Z"
}
}
```
# Import Template Pack
Source: https://docs.tess.im/en/de-import-template
POST https://api.tess.im/digital-employees/template-packs/import
Imports a template pack, creating or updating a digital employee from the pack configuration.
Import a template pack to create or update a digital employee. If no `target_agent_id` is provided, a new host agent is created automatically to receive the imported employee.
Run [Preview Template Import](/en/de-preview-import) first to validate the pack and check for conflicts before executing the import.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/template-packs/import' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/template-packs/import',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: {
target_agent_id: 99,
collision_strategy: 'rename',
pack: {}
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/template-packs/import"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
payload = {
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/template-packs/import",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'target_agent_id' => 99,
'collision_strategy' => 'rename',
'pack' => (object)[]
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String body = """
{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/template-packs/import"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io"
"net/http"
"strings"
)
func main() {
payload := strings.NewReader(`{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}`)
client := &http.Client{}
req, _ := http.NewRequest("POST",
"https://api.tess.im/digital-employees/template-packs/import",
payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using System.Text.Json;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var payload = new {
target_agent_id = 99,
collision_strategy = "rename",
pack = new {}
};
var content = new StringContent(
JsonSerializer.Serialize(payload),
Encoding.UTF8,
"application/json");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/template-packs/import",
content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/template-packs/import')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
target_agent_id: 99,
collision_strategy: 'rename',
pack: {}
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as a Bearer token on every request.
ID of the workspace. Required for all Digital Employees API requests.
### **Request Body**
The template pack payload obtained from [Export Template Pack](/en/de-export-template).
ID of the agent to import into. If omitted, a new host agent is created automatically.
How to handle naming conflicts with existing employees. Options:
* `skip` — keep existing employees, skip conflicting imports (default)
* `rename` — auto-rename imported employees to avoid conflicts
* `overwrite` — replace existing employees with imported configuration
### **Response**
Returns the import result object describing the employees created, updated, or skipped.
```json theme={null}
{
"data": {
"employees_created": [],
"employees_updated": [],
"employees_skipped": []
}
}
```
### **Errors**
* `422` with `reason: digital_employee_template_import_blocked` — the pack contains blocking issues that prevent import. Inspect the `blocking_issues` array in the response for details.
* `422` — invalid pack structure or missing required fields.
# Invoke Digital Employee
Source: https://docs.tess.im/en/de-invoke
POST https://api.tess.im/digital-employees/{employeeId}/invoke
Triggers a manual run of a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/{employeeId}/invoke' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--data '{}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/{employeeId}/invoke',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
data: {}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/digital-employees/{employeeId}/invoke"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.post(url, headers=headers, json={})
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/invoke",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "{}",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/invoke"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.ofString("{}"))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/digital-employees/{employeeId}/invoke", strings.NewReader("{}"))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var content = new StringContent("{}", Encoding.UTF8, "application/json");
try
{
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/{employeeId}/invoke",
content
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/invoke')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request.body = {}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Authentication is performed via the `Authorization: Bearer YOUR_API_KEY` header.
ID of the workspace. Required for all Digital Employees API endpoints.
### **Path Parameters**
The ID of the digital employee to invoke.
### **Response**
```json theme={null}
{
"message": "Run started.",
"data": {
"run": {
"id": 501,
"digital_employee_id": 123,
"status": "running",
"wake_reason": "manual",
"execution_id": 9001,
"started_at": "2026-06-24T17:30:00Z"
}
}
}
```
### **Errors**
| Code | Description |
| :---- | :---------------------------------------------------------------------------------- |
| `409` | A run is already in progress for this employee. Wait for the current run to finish. |
| `422` | The employee is not in an executable state (e.g., paused or missing configuration). |
# List Digital Employees
Source: https://docs.tess.im/en/de-list
GET https://api.tess.im/digital-employees
Returns a paginated list of all digital employees in the workspace.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees?per_page=15' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees',
params: { per_page: 15 },
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
params = { "per_page": 15 }
response = requests.get(url, headers=headers, params=params)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees?per_page=15",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees?per_page=15"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees?per_page=15", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync("https://api.tess.im/digital-employees?per_page=15");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees')
uri.query = URI.encode_www_form({ per_page: 15 })
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
The `Authorization` header must contain a valid Bearer token.
ID of the workspace.
### **Query Parameters**
Number of results per page. Default: `15`.
Filter employees by their linked agent ID.
### **Response**
```json theme={null}
{
"data": [
{
"id": 123,
"name": "Finance Ops",
"workspace_id": 10,
"status": "idle",
"agent_id": 99,
"created_at": "2026-06-24T17:00:00Z",
"updated_at": "2026-06-24T17:00:00Z"
}
],
"current_page": 1,
"per_page": 15,
"total": 1
}
```
# List Runs
Source: https://docs.tess.im/en/de-list-runs
GET https://api.tess.im/digital-employees/{employeeId}/runs
Returns a paginated list of execution runs for a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/{employeeId}/runs?limit=20&offset=0' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/{employeeId}/runs',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
params: {
limit: 20,
offset: 0
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}/runs"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
params = {
"limit": 20,
"offset": 0
}
response = requests.get(url, headers=headers, params=params)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/runs?limit=20&offset=0",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/runs?limit=20&offset=0"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/{employeeId}/runs?limit=20&offset=0", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync(
"https://api.tess.im/digital-employees/{employeeId}/runs?limit=20&offset=0");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/runs')
uri.query = URI.encode_www_form({ limit: 20, offset: 0 })
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
**Authorization:** Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The ID of the digital employee.
### **Query Parameters**
Maximum number of results to return. Default: `20`. Max: `100`.
Number of records to skip for pagination. Default: `0`.
Filter runs by status. Accepted values: `running`, `completed`, `failed`.
### **Response**
```json theme={null}
{
"data": [
{
"id": 501,
"digital_employee_id": 123,
"status": "completed",
"wake_reason": "manual",
"execution_id": 9001,
"started_at": "2026-06-24T17:30:00Z",
"finished_at": "2026-06-24T17:31:00Z"
}
]
}
```
# Pause Digital Employee
Source: https://docs.tess.im/en/de-pause
POST https://api.tess.im/digital-employees/{employeeId}/pause
Pauses a digital employee, preventing new scheduled runs from starting.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/pause' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: 10' \
--data '{"reason": "Maintenance window"}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/pause',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': '10'
},
data: {
reason: 'Maintenance window'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/pause"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "10"
}
payload = {
"reason": "Maintenance window"
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/pause",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode(["reason" => "Maintenance window"]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/pause"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.ofString("{\"reason\": \"Maintenance window\"}"))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
body := strings.NewReader(`{"reason": "Maintenance window"}`)
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/pause", body)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var content = new StringContent(
"{\"reason\": \"Maintenance window\"}",
Encoding.UTF8,
"application/json"
);
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/123/pause",
content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/123/pause')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = '10'
request.body = { reason: 'Maintenance window' }.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee to pause.
### **Body Parameters**
Optional reason for pausing. Stored for audit purposes.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"status": "paused",
"workspace_id": 10
}
}
```
# Preview Template Import
Source: https://docs.tess.im/en/de-preview-import
POST https://api.tess.im/digital-employees/template-packs/preview-import
Validates a template pack and returns a preview of what will be imported, including any conflicts.
Validate a template pack before committing to the import. This endpoint performs a dry run, returning a preview of which employees would be created, updated, or skipped — along with any blocking issues that would prevent the import from completing.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/template-packs/preview-import' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/template-packs/preview-import',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: {
target_agent_id: 99,
collision_strategy: 'rename',
pack: {}
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/template-packs/preview-import"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
payload = {
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/template-packs/preview-import",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'target_agent_id' => 99,
'collision_strategy' => 'rename',
'pack' => (object)[]
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String body = """
{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/template-packs/preview-import"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io"
"net/http"
"strings"
)
func main() {
payload := strings.NewReader(`{
"target_agent_id": 99,
"collision_strategy": "rename",
"pack": {}
}`)
client := &http.Client{}
req, _ := http.NewRequest("POST",
"https://api.tess.im/digital-employees/template-packs/preview-import",
payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using System.Text.Json;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var payload = new {
target_agent_id = 99,
collision_strategy = "rename",
pack = new {}
};
var content = new StringContent(
JsonSerializer.Serialize(payload),
Encoding.UTF8,
"application/json");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/template-packs/preview-import",
content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/template-packs/preview-import')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
target_agent_id: 99,
collision_strategy: 'rename',
pack: {}
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as a Bearer token on every request.
ID of the workspace. Required for all Digital Employees API requests.
### **Request Body**
The template pack payload obtained from [Export Template Pack](/en/de-export-template).
ID of the agent to import the template into.
How to handle naming conflicts with existing employees. Options:
* `skip` — keep existing employees, skip conflicting imports (default)
* `rename` — auto-rename imported employees to avoid conflicts
* `overwrite` — replace existing employees with imported configuration
### **Response**
Returns a preview object describing what would be created, updated, or skipped, without making any changes.
```json theme={null}
{
"data": {
"employees_to_create": [],
"employees_to_update": [],
"employees_to_skip": [],
"blocking_issues": []
}
}
```
### **Errors**
* `422` with `reason: digital_employee_template_import_blocked` — the pack contains blocking issues that prevent import. Inspect the `blocking_issues` array in the response for details.
* `422` — invalid pack structure or missing required fields.
# Reject Hire Request
Source: https://docs.tess.im/en/de-reject
POST https://api.tess.im/digital-employees/{employeeId}/reject
Rejects a digital employee hire request in pending_approval status.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/reject' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/reject',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/reject"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/reject",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/reject"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/reject", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.PostAsync("https://api.tess.im/digital-employees/123/reject", null);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/reject')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee to reject.
### **Response**
```json theme={null}
{
"message": "Hire request rejected."
}
```
Only digital employees in `pending_approval` status can be rejected. Attempting to reject an employee with a different status will return a `422` error.
# Reparent Digital Employee
Source: https://docs.tess.im/en/de-reparent
POST https://api.tess.im/digital-employees/{employeeId}/reparent
Assigns a new parent employee, making this employee a child of another.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/reparent' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: 10' \
--data '{"parent_employee_id": 100}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/reparent',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': '10'
},
data: {
parent_employee_id: 100
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/reparent"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "10"
}
payload = {
"parent_employee_id": 100
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/reparent",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode(["parent_employee_id" => 100]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/reparent"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.ofString("{\"parent_employee_id\": 100}"))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
body := strings.NewReader(`{"parent_employee_id": 100}`)
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/reparent", body)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var content = new StringContent(
"{\"parent_employee_id\": 100}",
Encoding.UTF8,
"application/json"
);
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/123/reparent",
content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/123/reparent')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = '10'
request.body = { parent_employee_id: 100 }.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee to reassign to a new parent.
### **Body Parameters**
ID of the new parent digital employee. The parent must exist in the same workspace.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"parent_employee_id": 100,
"workspace_id": 10
}
}
```
Use [Detach](/en/de-detach) to remove a parent relationship without setting a new one.
# Resume Digital Employee
Source: https://docs.tess.im/en/de-resume
POST https://api.tess.im/digital-employees/{employeeId}/resume
Resumes a paused digital employee, re-enabling scheduled runs.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/resume' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/resume',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/resume"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/resume",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/resume"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/resume", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/123/resume",
null
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/resume')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee to resume.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"status": "active",
"workspace_id": 10
}
}
```
# Retry Run
Source: https://docs.tess.im/en/de-retry-run
POST https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry
Re-executes a finished run of a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry",
null);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/retry')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
**Authorization:** Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The ID of the digital employee.
The ID of the finished run to retry.
### **Response**
```json theme={null}
{
"message": "Run started.",
"data": {
"run": {
"id": 502,
"digital_employee_id": 123,
"status": "running",
"wake_reason": "retry",
"execution_id": 9002,
"started_at": "2026-06-24T18:00:00Z"
}
}
}
```
### **Errors**
| Status | Description |
| :----- | :---------------------------------------------- |
| `422` | The employee is not in an executable state. |
| `409` | A run is already in progress for this employee. |
# Rollback Digital Employee
Source: https://docs.tess.im/en/de-rollback
POST https://api.tess.im/digital-employees/{employeeId}/rollback
Restores a digital employee to a previous version.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/123/rollback' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: 10' \
--data '{"version": 6}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/123/rollback',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': '10'
},
data: {
version: 6
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/rollback"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "10"
}
payload = {
"version": 6
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/rollback",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode(["version" => 6]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/rollback"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "10")
.POST(HttpRequest.BodyPublishers.ofString("{\"version\": 6}"))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
body := strings.NewReader(`{"version": 6}`)
req, _ := http.NewRequest("POST", "https://api.tess.im/digital-employees/123/rollback", body)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var content = new StringContent(
"{\"version\": 6}",
Encoding.UTF8,
"application/json"
);
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/123/rollback",
content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/123/rollback')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = '10'
request.body = { version: 6 }.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee to roll back.
### **Body Parameters**
The version number to restore. Must be `>= 1`. Use [Get Rollback Options](/en/de-rollback-options) to see the list of available versions.
### **Response**
```json theme={null}
{
"success": true,
"restored_from_version": 6,
"new_current_version": 9,
"message": "Rollback completed successfully.",
"employee": {}
}
```
# Get Rollback Options
Source: https://docs.tess.im/en/de-rollback-options
GET https://api.tess.im/digital-employees/{employeeId}/rollback-options
Returns the list of available versions to roll back to for a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/123/rollback-options?limit=5' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/123/rollback-options',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
},
params: {
limit: 5
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/rollback-options"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
params = {
"limit": 5
}
response = requests.get(url, headers=headers, params=params)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/rollback-options?limit=5",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/rollback-options?limit=5"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/123/rollback-options?limit=5", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.GetAsync(
"https://api.tess.im/digital-employees/123/rollback-options?limit=5"
);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/rollback-options')
uri.query = URI.encode_www_form({ limit: 5 })
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. If not provided, the user's selected workspace will be used.
### **Path Parameters**
ID of the digital employee whose rollback options you want to retrieve.
### **Query Parameters**
Number of versions to return. Default: `5`. Min: `1`. Max: `20`.
### **Response**
```json theme={null}
{
"current_version": 8,
"items": [
{
"version": 7,
"change_source": "update",
"changed_fields": ["name", "heartbeat_cron"],
"changed_by": { "id": 1, "name": "Alice" },
"created_at": "2026-06-24T17:00:00Z"
},
{
"version": 6,
"change_source": "update",
"changed_fields": ["system_prompt_override"],
"changed_by": { "id": 1, "name": "Alice" },
"created_at": "2026-06-23T10:00:00Z"
}
]
}
```
# Get Run Output
Source: https://docs.tess.im/en/de-run-output
GET https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output
Returns the consolidated output of a completed run.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var response = await client.GetAsync(
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/output')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
**Authorization:** Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The ID of the digital employee.
The ID of the completed run.
### **Response**
```json theme={null}
{
"data": {
"output": "The financial report for Q2 is complete...",
"rendered_output": "The financial report for Q2 is complete...",
"input": "Generate Q2 financial report",
"tool_call_count": 3,
"generated_files": [],
"workspace_files": [],
"affected_documents": [],
"tool_calls": [],
"artifacts": [],
"execution_id": 9001,
"chat_id": 9001,
"search_intelligence": null,
"approval": null,
"approvals": [],
"user_input_request": null
}
}
```
### **Response Fields**
| Field | Description |
| :------------------- | :----------------------------------------------------------------- |
| `output` | Raw text output produced by the run. |
| `rendered_output` | Output with formatting markers applied. |
| `input` | The prompt or input used for the run. |
| `tool_call_count` | Total number of tool calls made during the run. |
| `generated_files` | Files generated during the run. |
| `workspace_files` | Workspace files referenced or modified during the run. |
| `artifacts` | Structured artifacts produced by the run. |
| `approval` | Approval request object if approval is required. |
| `user_input_request` | Pending user input request if the run is paused waiting for input. |
# Stream Run
Source: https://docs.tess.im/en/de-run-stream
GET https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream
Opens a Server-Sent Events (SSE) stream to follow a run in real time.
The stream endpoint uses Server-Sent Events (SSE) to deliver incremental run output. Connect to this endpoint while a run is `running` to receive output as it is generated.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Accept: text/event-stream' \
--no-buffer
```
```json Node.js theme={null}
const https = require('https');
const options = {
hostname: 'api.tess.im',
path: '/digital-employees/{employeeId}/runs/{runId}/stream',
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Accept': 'text/event-stream'
}
};
const req = https.request(options, (res) => {
res.on('data', (chunk) => {
const lines = chunk.toString().split('\n');
lines.forEach((line) => {
if (line.startsWith('data: ')) {
const data = JSON.parse(line.slice(6));
if (data.delta) process.stdout.write(data.delta);
if (data.status === 'completed') console.log('\nRun completed.');
}
});
});
});
req.on('error', console.error);
req.end();
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Accept": "text/event-stream"
}
with requests.get(url, headers=headers, stream=True) as response:
for line in response.iter_lines():
if line:
decoded = line.decode('utf-8')
if decoded.startswith('data: '):
data = json.loads(decoded[6:])
if 'delta' in data:
print(data['delta'], end='', flush=True)
if data.get('status') == 'completed':
print('\nRun completed.')
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream",
CURLOPT_RETURNTRANSFER => false,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Accept: text/event-stream"
],
CURLOPT_WRITEFUNCTION => function($curl, $data) {
$lines = explode("\n", $data);
foreach ($lines as $line) {
if (str_starts_with($line, 'data: ')) {
$payload = json_decode(substr($line, 6), true);
if (isset($payload['delta'])) echo $payload['delta'];
if (($payload['status'] ?? '') === 'completed') echo "\nRun completed.";
}
}
return strlen($data);
}
]);
curl_exec($curl);
curl_close($curl);
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Accept", "text/event-stream")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofInputStream());
try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
String line;
while ((line = reader.readLine()) != null) {
if (line.startsWith("data: ")) {
System.out.println(line.substring(6));
}
}
}
```
```go Go theme={null}
package main
import (
"bufio"
"fmt"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET",
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Accept", "text/event-stream")
resp, _ := client.Do(req)
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
line := scanner.Text()
if strings.HasPrefix(line, "data: ") {
fmt.Println(line[6:])
}
}
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.IO;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
client.DefaultRequestHeaders.Add("Accept", "text/event-stream");
using var response = await client.GetAsync(
"https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream",
HttpCompletionOption.ResponseHeadersRead);
using var stream = await response.Content.ReadAsStreamAsync();
using var reader = new StreamReader(stream);
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync();
if (line != null && line.StartsWith("data: "))
Console.WriteLine(line.Substring(6));
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/{employeeId}/runs/{runId}/stream')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Accept'] = 'text/event-stream'
http.request(request) do |response|
response.read_body do |chunk|
chunk.split("\n").each do |line|
if line.start_with?('data: ')
puts line[6..]
end
end
end
end
```
### **Headers**
**Authorization:** Pass your API key as a Bearer token in the `Authorization` header: `Authorization: Bearer YOUR_API_KEY`.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The ID of the digital employee.
The ID of the run to stream.
### **SSE Events**
| Event | Description |
| :---------- | :---------------------------------------------------------------------------------------------------------- |
| `delta` | Incremental output chunk. Contains partial text output as the run progresses. |
| `complete` | Final snapshot with `status`, `output`, `rendered_output`, and run metadata. Signals the end of the stream. |
| `heartbeat` | Keep-alive comment (`: heartbeat`) sent periodically to maintain the connection. |
### **delta Event Shape**
```
data: {"delta": "The financial report..."}
```
### **complete Event Shape**
```
data: {"status": "completed", "output": "The financial report for Q2 is complete.", "rendered_output": "...", "execution_id": 9001}
```
Connect to this endpoint only while the run status is `running`. If the run has already finished, use [Get Run Output](/en/de-run-output) instead.
# Get Runs Summary
Source: https://docs.tess.im/en/de-runs-summary
GET https://api.tess.im/digital-employees/{employeeId}/runs/summary
Returns aggregated statistics about the runs of a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/digital-employees/123/runs/summary' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/digital-employees/123/runs/summary',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/runs/summary"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/runs/summary",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/runs/summary"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://api.tess.im/digital-employees/123/runs/summary", nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var response = await client.GetAsync("https://api.tess.im/digital-employees/123/runs/summary");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/digital-employees/123/runs/summary')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee.
### **Response**
```json theme={null}
{
"data": {
"total_runs": 42,
"completed_runs": 38,
"failed_runs": 4,
"running_runs": 0,
"last_run_at": "2026-06-24T17:31:00Z"
}
}
```
# Preview Schedule
Source: https://docs.tess.im/en/de-schedule-preview
POST https://api.tess.im/digital-employees/schedule-preview
Validates a schedule definition and returns the next planned occurrences.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/digital-employees/schedule-preview' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--data '{
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
};
const config = {
method: 'post',
url: 'https://api.tess.im/digital-employees/schedule-preview',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
data: data
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/digital-employees/schedule-preview"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
data = {
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}
response = requests.post(url, headers=headers, json=data)
print(response.json())
```
```php PHP theme={null}
"0 9 * * 1-5",
"execution_timezone" => "America/Sao_Paulo"
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/digital-employees/schedule-preview",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;
public class Main {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
Map data = Map.of(
"heartbeat_cron", "0 9 * * 1-5",
"execution_timezone", "America/Sao_Paulo"
);
String jsonPayload = mapper.writeValueAsString(data);
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/schedule-preview"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"io/ioutil"
"net/http"
)
func main() {
payload := `{
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}`
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/digital-employees/schedule-preview", strings.NewReader(payload))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = new
{
heartbeat_cron = "0 9 * * 1-5",
execution_timezone = "America/Sao_Paulo"
};
var jsonPayload = JsonConvert.SerializeObject(data);
var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
try
{
var response = await client.PostAsync(
"https://api.tess.im/digital-employees/schedule-preview",
content
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/schedule-preview')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request.body = {
"heartbeat_cron": "0 9 * * 1-5",
"execution_timezone": "America/Sao_Paulo"
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Authentication is performed via the `Authorization: Bearer YOUR_API_KEY` header.
ID of the workspace. Required for all Digital Employees API endpoints.
### **Body Parameters**
At least one of `heartbeat_cron` or `heartbeat_schedule_json` must be provided in the request body.
Cron expression defining the schedule (e.g. `0 9 * * 1-5` for weekdays at 9 AM). At least one of `heartbeat_cron` or `heartbeat_schedule_json` must be provided.
Schedule builder config object. Alternative to `heartbeat_cron`. At least one of `heartbeat_cron` or `heartbeat_schedule_json` must be provided.
Timezone for evaluating the schedule (e.g. `America/Sao_Paulo`). Defaults to UTC if not provided.
### **Response**
```json theme={null}
{
"data": {
"effective_cron": "0 9 * * 1-5",
"next_occurrences": [
"2026-06-30T09:00:00-03:00",
"2026-07-01T09:00:00-03:00",
"2026-07-02T09:00:00-03:00"
]
}
}
```
# Update Digital Employee
Source: https://docs.tess.im/en/de-update
PUT https://api.tess.im/digital-employees/{employeeId}
Updates one or more fields of an existing digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request PUT \
--url 'https://api.tess.im/digital-employees/123' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--data '{
"name": "Finance Ops Updated",
"status": "active",
"execution_approval_mode": "approval_required"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const employeeId = 123;
const config = {
method: 'put',
url: `https://api.tess.im/digital-employees/${employeeId}`,
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
},
data: {
name: 'Finance Ops Updated',
status: 'active',
execution_approval_mode: 'approval_required'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
employee_id = 123
url = f"https://api.tess.im/digital-employees/{employee_id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
payload = {
"name": "Finance Ops Updated",
"status": "active",
"execution_approval_mode": "approval_required"
}
response = requests.put(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/{$employeeId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
"name" => "Finance Ops Updated",
"status" => "active",
"execution_approval_mode" => "approval_required"
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"Content-Type: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
int employeeId = 123;
String body = """
{
"name": "Finance Ops Updated",
"status": "active",
"execution_approval_mode": "approval_required"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/" + employeeId))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("Content-Type", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.PUT(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
employeeId := 123
payload := strings.NewReader(`{
"name": "Finance Ops Updated",
"status": "active",
"execution_approval_mode": "approval_required"
}`)
client := &http.Client{}
url := fmt.Sprintf("https://api.tess.im/digital-employees/%d", employeeId)
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
int employeeId = 123;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var json = """
{
"name": "Finance Ops Updated",
"status": "active",
"execution_approval_mode": "approval_required"
}
""";
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PutAsync(
$"https://api.tess.im/digital-employees/{employeeId}", content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
employee_id = 123
uri = URI("https://api.tess.im/digital-employees/#{employee_id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request.body = {
name: 'Finance Ops Updated',
status: 'active',
execution_approval_mode: 'approval_required'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Pass your API key as a Bearer token in the `Authorization` header.
ID of the workspace.
### **Path Parameters**
ID of the digital employee to update.
### **Request Body**
All fields are optional. Only the fields provided will be updated.
Employee name. Max 255 characters.
Set employee status. Values: `idle` or `active`.
Execution mode. Values: `agent` (autonomous) or `chat`.
Whether runs require manual approval. Values: `autonomous` or `approval_required`.
Cron expression for scheduled runs (e.g. `0 9 * * 1-5`). Max 128 characters.
Schedule builder config (alternative to `heartbeat_cron`).
Timezone for schedule execution (e.g. `America/Sao_Paulo`). Max 64 characters.
Minimum seconds between runs. Either `0` (no limit) or `>= 60`.
Custom system prompt for this employee. Max 4096 characters.
Override the AI model (e.g. `tess-6`). Max 100 characters.
Override tool configuration. Max 255 characters.
Enable Search Intelligence for runs.
Array of connector identifiers to enable.
Array of skill identifiers to override.
Max consecutive run failures before auto-pause. Range: 1–100.
Execution priority order. Range: 0–999.
Whether the employee shares memory with its owner agent.
Array of file IDs for the knowledge base. Max 20 entries.
Avatar image URL. Max 2048 characters.
Thumbnail image URL. Max 2048 characters.
MBTI personality type (e.g. `INTJ`).
Wake policy configuration object.
Budget policy configuration object.
Goal configuration object.
Work policy configuration object.
Voice identifier for real-time voice mode.
Delegation configuration object. Supported fields:
* `trigger`: `on_delegate_tag` | `on_schedule` | `on_parent_complete`
* `parallel`: boolean — run children in parallel
* `context_mode`: `summary` | `full` | `none`
* `max_concurrent_children`: integer (1–10)
* `inherit_budget`: boolean
* `auto_delegate_on_schedule`: boolean
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops Updated",
"status": "active"
}
}
```
# Update Goal
Source: https://docs.tess.im/en/de-update-goal
PUT https://api.tess.im/digital-employees/{employeeId}/goal
Sets or updates the goal definition for a digital employee.
### **Code Examples**
```http cURL theme={null}
curl --request PUT \
--url 'https://api.tess.im/digital-employees/123/goal' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: 10' \
--header 'Content-Type: application/json' \
--data '{
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'put',
url: 'https://api.tess.im/digital-employees/123/goal',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': '10',
'Content-Type': 'application/json'
},
data: {
title: 'Increase Q3 revenue by 15%',
description: 'Monitor and report on key revenue metrics weekly.',
success_criteria: 'Revenue reaches $1.5M by September 30',
status: 'active'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/digital-employees/123/goal"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "10",
"Content-Type": "application/json"
}
payload = {
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}
response = requests.put(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/digital-employees/123/goal",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
"title" => "Increase Q3 revenue by 15%",
"description" => "Monitor and report on key revenue metrics weekly.",
"success_criteria" => "Revenue reaches \$1.5M by September 30",
"status" => "active"
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: 10",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
curl_close($curl);
echo $response;
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String body = """
{
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/digital-employees/123/goal"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "10")
.header("Content-Type", "application/json")
.PUT(HttpRequest.BodyPublishers.ofString(body))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
payload := strings.NewReader(`{
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}`)
client := &http.Client{}
req, _ := http.NewRequest("PUT", "https://api.tess.im/digital-employees/123/goal", payload)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "10")
req.Header.Add("Content-Type", "application/json")
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System.Net.Http;
using System.Text;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "10");
var json = """
{
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}
""";
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PutAsync("https://api.tess.im/digital-employees/123/goal", content);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/digital-employees/123/goal')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = '10'
request['Content-Type'] = 'application/json'
request.body = {
title: 'Increase Q3 revenue by 15%',
description: 'Monitor and report on key revenue metrics weekly.',
success_criteria: 'Revenue reaches $1.5M by September 30',
status: 'active'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Include your API key in the `Authorization` header as `Bearer YOUR_API_KEY` on all requests.
ID of the workspace. Required for all Digital Employees API requests.
### **Path Parameters**
The unique identifier of the digital employee.
### **Body Parameters**
Goal title. Max 500 characters.
Detailed goal description. Max 2000 characters.
Measurable criteria for goal completion. Max 1000 characters.
Goal status. Accepted values: `planned`, `active`, `achieved`, `cancelled`.
### **Response**
```json theme={null}
{
"data": {
"id": 123,
"name": "Finance Ops",
"goal_json": {
"title": "Increase Q3 revenue by 15%",
"description": "Monitor and report on key revenue metrics weekly.",
"success_criteria": "Revenue reaches $1.5M by September 30",
"status": "active"
}
}
}
```
# Delete Agent File
Source: https://docs.tess.im/en/delete-agent-file
DELETE https://api.tess.im/agents/{agentId}/files/{fileId}
Deletes a specific file associated with an agent.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url '
\
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'delete',
url: '
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("DELETE", "
nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.DeleteAsync("
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
The ID of the file to delete
### **Resposta**
```json theme={null}
{
"id": 8794,
"file": {
"id": 73336,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:39:57+00:00",
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
},
"removed": true
}
```
# Dynamic Training
Source: https://docs.tess.im/en/dynamic-training
"User Inputs" are an essential feature in Agent Studio for creating more interactive and customizable AI agents. Instead of relying on a single text instruction, you can build forms and structured fields to collect exactly the information your agent needs to perform a task.
In this guide, we’ll explore the five types of user input available on the Tess platform, showing how and when to use each one to enhance your creations.
### How to Set Up a User Input
Before we explore the input types, the process for adding them is always the same and happens in your agent’s configuration panel.
There you’ll see the "User Input" option—click it to create a new input field.
For each variable, you will configure (at least) three main fields:
The input format the user will fill out (text, list, file, etc.).
The variable’s internal name, which will be used in the instruction (prompt). Use short names, without accents or special characters.
The text that will be shown to the end user, guiding them on how to fill it in.
### Exploring the Input Types
Now, let’s detail each of the input types you can configure.
Ideal for collecting brief and direct information. Use this field when the user needs to fill in a word, a phrase, or a specific piece of data.
What it’s for: Collecting names, emails, order numbers, search terms, document titles, etc.
> Usage example: You can create an agent that generates personalized greetings. The Client Name variable (Short Text) would ask for the client’s name:
>
> And the instruction would be: "Create a friendly greeting for **client-name**"
Perfect for situations where the user needs to provide a large volume of information, such as a full text, a detailed paragraph, or a code block.
What it’s for: Allowing the user to paste an email to be summarized, an article to be analyzed, a problem description to be diagnosed, or code to be debugged.
> Usage example: A text review agent. The Full Text variable (Long Text) would ask the user to paste the text.
>
> And the instruction would be: "Review the following text and correct grammatical errors: **full-text**"
Use the dropdown to ensure the user’s response is standardized. It presents a list of predefined options, from which the user can choose only one.
What it’s for: Limiting the choice to a set of options, such as selecting a language (Portuguese, English), a department (Sales, Support), a tone of voice (Formal, Informal), or a specific action (Translate, Summarize).
> Usage example:
>
> A translation agent. The target\_language variable (Dropdown) would offer options like "English", "Spanish", and "French".
>
> The instruction would be: "Translate the following text to **target\_language**."
Similar to the dropdown, but with the flexibility to let the user select multiple options from a predefined list.
What it’s for: When the user can choose more than one valid alternative, such as selecting topics of interest for a report, the social networks to publish a post, or product features to include in a description.
> Usage example:
>
> A campaign creation agent. The social\_networks variable (Multiple Choice) would list "Facebook", "Instagram", and "LinkedIn".
>
> The instruction would be: "Create a post about AI for the following networks: **social\_networks**."
This input type turns your agent into a powerful document analyst, allowing the user to attach files for processing.
What it’s for: Analyzing contracts in PDF, extracting data from spreadsheets in XLSX or CSV, summarizing reports in DOCX, or interpreting the contents of any text file.
> Usage example:
>
> An agent that analyzes spreadsheets. The sales\_spreadsheet variable (File) would ask for the file upload.
>
> The instruction would be: "Based on the **sales\_spreadsheet** spreadsheet, calculate total sales for the last quarter."
# Errors
Source: https://docs.tess.im/en/errors
The Tess AI API uses conventional HTTP response codes to indicate the success or failure of an API request. In general:
* Codes in the `2xx` range indicate success
* Codes in the `4xx` range indicate an error that failed given the information provided
* Codes in the `5xx` range indicate an error with our servers (these are rare)
## **HTTP Status Codes**
| **Status Code** | **Description** | **Common Causes** |
| :-------------- | :------------------------------------------------------------------- | :-------------------------------------------------------------------------------- |
| 200 | Success - The request was successful | Request completed as expected |
| 201 | Created - The resource was successfully created | New webhook created successfully |
| 400 | Bad Request - The request was invalid | Missing required fields, invalid parameter values |
| 403 | Forbidden - Authentication failed | Invalid API key, expired token, insufficient permissions |
| 413 | Payload Too Large - Request body exceeds allowed size | File exceeds maximum upload size |
| 422 | Unprocessable Entity - Required workspace context missing or invalid | Missing `x-workspace-id` header (required as of 2026-09-01), invalid workspace id |
| 429 | Rate Limited - Too many requests | Exceeded API rate limits |
| 500 | Internal Server Error - Server issue | Unexpected server error (please contact support) |
## **Error Types and Examples**
### **Authentication Errors (403)**
These errors occur when there's a problem with your API key:
```
{
"error": "Invalid authentication"
}
```
Common causes:
* Invalid API key
* Expired API key
* Missing Authorization header
* Insufficient permissions
### **Validation Errors (400)**
Occur when the request data doesn't meet the requirements:
```
{
"error": "Validation failed",
"messages": {
"url": ["The url field must be a valid HTTPS URL"],
"method": ["The method must be one of: POST, GET"]
}
}
```
Common validation rules:
* **Webhooks**
* URL must be a valid HTTPS URL
* Method must be either POST or GET
* Status must be either "active" or "inactive"
* **Files**
* File must be provided for upload
* Process flag is optional (default: false)
### **Missing workspace header (422)**
As of **2026-09-01**, authenticated API requests must include `x-workspace-id`. If the header is missing:
```
{
"message": "The x-workspace-id header is required."
}
```
Until that date, omitting the header falls back to the user's selected workspace (deprecated). Send `x-workspace-id` on every request to stay compatible.
### **Rate Limit Errors (429)**
Occur when you've exceeded the API rate limits:
```
{
"error": "Rate limit exceeded",
"retry_after": 60
}
```
### **Server Errors (500)**
Indicate an issue on our end:
```
{
"error": "Internal server error"
}
```
# Execute Agent
Source: https://docs.tess.im/en/execute-agent
api-reference/agents-execution.openapi.json POST /agents/{id}/execute
Execute a specific agent by ID.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{id}/execute' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "Hello, how can you help me today?" }
],
"tools": "no-tools",
"waitExecution": false,
"file_ids": [123, 321],
"memory_collections": [456]
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "Hello, how can you help me today?" }
],
"tools": "no-tools",
"waitExecution": false,
"file_ids": [123, 321],
"memory_collections": [456]
};
const config = {
method: 'post',
url: 'https://api.tess.im/agents/{id}/execute',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: data
};
const response = await axios(config);
console.log(response.data);
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/agents/{id}/execute"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
data = {
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "Hello, how can you help me today?" }
],
"tools": "no-tools",
"waitExecution": False,
"file_ids": [123, 321],
"memory_collections": [456]
}
response = requests.post(url, headers=headers, json=data)
print(response.json())
```
```php PHP theme={null}
"1",
"model" => "tess-5",
"messages" => [
[ "role" => "user", "content" => "Hello, how can you help me today?" ]
],
"tools" => "no-tools",
"waitExecution" => false,
"file_ids" => [123, 321],
"memory_collections" => [456]
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/agents/{id}/execute",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
Map data = Map.of(
"temperature", "1",
"model", "tess-5",
"messages", List.of(Map.of("role", "user", "content", "Hello, how can you help me today?")),
"tools", "no-tools",
"waitExecution", false,
"file_ids", List.of(123, 321),
"memory_collections", List.of(456)
);
String jsonPayload = mapper.writeValueAsString(data);
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{id}/execute"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"io/ioutil"
"net/http"
)
func main() {
payload := `{
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "Hello, how can you help me today?" }
],
"tools": "no-tools",
"waitExecution": false,
"file_ids": [123, 321],
"memory_collections": [456]
}`
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/agents/{id}/execute", strings.NewReader(payload))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.Collections.Generic;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = new
{
temperature = "1",
model = "tess-5",
messages = new List
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
| **Parameter** | **Type** | **Required** | **Description** |
| :------------ | :------- | :----------- | :-------------- |
| `id` | integer | Yes | The agent ID. |
### **Request Body**
| **Parameter** | **Type** | **Required** | **Description** |
| :---------------------- | :------- | :--------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `temperature` | string | No | Chat Agent field. Sampling temperature between 0 and 2. Higher values produce more creative outputs (default: `"1"`). |
| `model` | string | No | Chat Agent field. Model identifier to use for execution (e.g., `"tess-6"`). |
| `tools` | string | No | Chat Agent field. Tool configuration for the agent (e.g., `"agent"`, `"no-tools"`). |
| `root_id` | integer | No | Chat Agent field. ID of an existing execution to continue a conversation thread. |
| `messages` | array | No | Chat Agent field. The agent messages. Required for Chat Agent templates. Supports `user`, `assistant`, `developer` roles. |
| `waitExecution` | boolean | No | If `true`, waits for execution to finish before returning (timeout: 100 s). Default: `false`. |
| `file_ids` | array | No | Array of file IDs to attach to the execution. |
| `memory_collections` | array | No | Array of [Memory Collection](https://docs.tess.im/en/list-collections) IDs to use in this execution. Memories indexed in these collections are automatically retrieved and injected into the agent context via semantic search. |
| Other root-level fields | any | Depends on agent | This is not a fixed field name. You can send additional fields required by your specific agent directly at the request root. Check which fields are required in [Get Agent by ID](https://docs.tess.im/en/get-agent). |
**How to use memories in an execution**
To inject memory context into an agent, pass Memory Collection IDs in the `memory_collections` field. The full flow is:
1. **Create a Collection** — `POST /api/memory-collections` — and save the returned `id`.
2. **Create Memories** — `POST /api/memories` — passing `collection_id` and the memory text in the `memory` field.
3. **Execute the Agent** — include `"memory_collections": [collection_id]` in the request body.
The agent will automatically use the relevant memories to contextualize the response.
See the full guide at [Memories](https://docs.tess.im/en/memories).
#### **Messages Roles (Chat Type Templates)**
For chat type templates, the `messages` array supports the following roles:
| **Role** | **Required** | **Description** |
| :---------- | :----------- | :------------------------------------------------------------------------------ |
| `user` | Yes | User messages. Must be paired with `assistant` messages. |
| `assistant` | Yes | Assistant messages. Must be paired with `user` messages. |
| `developer` | No | Optional developer message. **Only allowed as the first message** in the array. |
| `system` | No | **Not supported**. Using this role will cause an error. |
**Important rules:**
* Messages must alternate between `user` and `assistant` roles (after the optional `developer` message).
* The `developer` role can only appear as the first message in the array and will be extracted before processing the rest.
* If two consecutive messages have the same role (e.g., two `user` messages), the API will return a validation error: "Chat messages must be a pair of user/assistant".
* The `system` role is not supported and will cause an error.
**Example with developer message:**
```json theme={null}
{
"messages": [
{ "role": "developer", "content": "You are a helpful assistant." },
{ "role": "user", "content": "Hello!" },
{ "role": "assistant", "content": "Hi there! How can I help you?" },
{ "role": "user", "content": "What's the weather like?" }
]
}
```
**Example without developer message:**
```json theme={null}
{
"messages": [
{ "role": "user", "content": "Hello!" },
{ "role": "assistant", "content": "Hi there! How can I help you?" },
{ "role": "user", "content": "What's the weather like?" }
]
}
```
Get more details of which options are accepted by this Agent requesting this endpoint: [Get Agent](https://docs.tess.im/en/get-agent)
### **Response**
```json theme={null}
{
"template_id": "8794",
"responses": [
{
"id": 4773337,
"status": "starting",
"input": "hello",
"output": "",
"credits": 0.000337,
"root_id": 4773337,
"created_at": "2025-01-05T19:35:21.000000Z",
"updated_at": "2025-01-05T19:35:21.000000Z",
"template_id": 8794
}
]
}
```
# Get Agent
Source: https://docs.tess.im/en/get-agent
GET https://api.tess.im/agents/{id}
Retrieve a specific agent by ID.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents/{id}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents/{id}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/{id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/{id}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{id}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents/{id}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents/{id}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/{id}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
## Headers
| **Parameter** | **Type** | **Required** | **Description** |
| :------------- | :------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| x-workspace-id | integer | Yes | Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**. |
## Path parameters
The agent ID
## Response
```json theme={null}
{
"id": 8794,
"title": "Tess AI - API Docs Helper",
"description": null,
"long_description": null,
"workspace_id": 11,
"visibility": "public",
"slug": "tess-ai-docs-helper-pB9ujA",
"active": 1,
"type": "chat",
"questions": [
{
"type": "select",
"name": "temperature",
"description": "Let Tess know if you want her to be more objective or more creative with her responses.",
"required": true,
"options": [
"0",
"0.25",
"0.5",
"0.75",
"1"
]
},
{
"type": "select",
"name": "model",
"description": "Choose the Model version",
"required": true,
"options": [
"gpt-4o-mini",
"gpt-4o",
"tess-5",
"tess-ai-3",
"gpt-o1-preview",
"gpt-o1-mini",
"gemini-2.0-flash",
"gemini-1.5-flash",
"gemini-1.5-pro",
"claude-3-5-haiku-latest",
"claude-3-5-sonnet-20240620",
"claude-3-5-sonnet-latest",
"claude-3-opus-20240229",
"meta-llama-3.1-405b-instruct",
"meta-llama-3-70b-instruct",
"meta-llama-3-8b-instruct",
"cohere-command-r",
"cohere-command-r-plus",
"gpt-3.5-turbo",
"gpt-4-turbo",
"claude-3-haiku-20240307",
"claude-3-sonnet-20240229",
"gemini-1.0-pro",
"llama-2-13b-chat",
"llama-2-70b-chat"
]
},
{
"type": "select",
"name": "tools",
"description": "Choose the Model version",
"required": true,
"options": [
"no-tools",
"internet",
"twitter",
"wikipedia",
"quora",
"reddit",
"medium",
"linkedin",
"instagram",
"facebook"
]
},
{
"type": "number",
"name": "root_id",
"description": "The stored session id to continue conversation.",
"required": false
},
{
"type": "array",
"name": "messages",
"description": "Chat history messages",
"required": true
}
],
"created_at": "2025-01-05T18:09:18.000000Z",
"updated_at": "2025-01-05T18:45:31.000000Z",
"created_by": 13
}
```
# AI Step | Google Ads
Source: https://docs.tess.im/en/google-ads
The Google Ads step allows your agents to manage campaigns directly from Tess. This includes everything from budget and status adjustments to full performance reports. With it, AI can act as an autonomous paid media manager, executing actions and generating insights without manual intervention.
### **What is the Step?**
This integration connects Tess to Google Ads and provides six actions divided into two categories:
Actions (execute changes in campaigns)
* Change Campaign Budget → changes the budget of a specific campaign
* Change Campaign Status → enables or pauses a campaign
* Budget Shift Campaigns → redistributes budget across campaigns based on performance
Reports (collect and analyze data)
* Keyword Performance Report → analyzes keywords
* Metrics Trend Report → analyzes metric trends over time
* Search Term Performance Report → analyzes search terms that triggered campaigns
### **Where to find it**
1. AI Studio
2. Add AI Step
3. App Integration
4. Google Ads
5. Choose the desired action
## **How to use (Quickstart by action)**
### **1. Change Campaign Budget**
Changes the budget of a specific campaign with control over the change method.
| **Field** | **Description** |
| :----------------------- | :-------------------------------------------------------------------------- |
| Step Name | Internal step name |
| Google Ads Account ID \* | Ads account ID. Ex: `1234567890` |
| Campaign ID \* | Campaign ID to be changed. Ex: `1234567890` |
| Budget Change Method \* | Change method. Option: `Set Exact Amount` |
| Budget Change Value \* | Value to apply. Ex: `100.00` (fixed), `30` (percentage) or `-20` (decrease) |
This step allows you to either define an exact value or apply a relative adjustment, depending on the Budget Change Method logic.
***
### 2. Change Campaign Status
Enables or pauses a campaign directly via the agent.
| **Field** | **Description** |
| :----------------------- | :----------------------------------------- |
| Step Name | Internal step name |
| Google Ads Account ID \* | Ads account ID |
| Campaign ID \* | Campaign ID |
| New Campaign Status \* | `enabled` to activate or `paused` to pause |
Attention: this action impacts real and active campaigns. Make sure the IDs are correct before saving.
***
### 3. Budget Shift Campaigns
Redistributes budget across campaigns based on performance analysis.
| **Field** | **Description** |
| :--------------------------- | :------------------------------------------------------- |
| Step Name | Internal step name |
| Google Ads MCC ID \* | Manager account ID |
| Google Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Analysis period. Ex: `30` |
| Has New Budget Allocation \* | `Yes` or `No` |
| New Budget | New budget value. Ex: `2500.00` |
| Percent Adjust | Percentage adjustment. Ex: `20` or `20%` |
| Excluded Campaigns ID | Campaign IDs to ignore in redistribution. Ex: `123, 456` |
***
### **4. Keyword Performance Report**
Analyzes keyword performance over a period.
| Field | Description |
| :------------------------ | :------------------------ |
| Step Name | Internal step name |
| Google Ads MCC ID \* | Manager account ID |
| Google Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Period analyzed. Ex: `30` |
***
### **5. Metrics Trend Report**
Analyzes the trend of a metric over time by segment.
| **Field** | **Description** |
| :--------------------------------- | :------------------------------ |
| Step Name | Internal step name |
| Google Ads MCC ID \* | Manager account ID |
| Google Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Period analyzed. Ex: `30` |
| Report Segment \* | Report segment. Ex: `campaigns` |
| Key Performance Indicator (KPI) \* | Main metric. Ex: `cpa`, `roas` |
***
### **6. Search Term Performance Report**
Analyzes the search terms that triggered campaigns and evaluates their performance.
| **Field** | **Description** |
| :------------------------ | :------------------------------------------------------------ |
| Step Name | Internal step name |
| Google Ads MCC ID \* | Manager account ID |
| Google Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Period analyzed. Ex: `30` |
| Campaigns for Analysis \* | Campaign names. Ex: `Campaign 1, Campaign 2` |
| KPIs for Analysis \* | Select: `CPA`, `ROAS`, `Clicks`, `CPC`, `Conversions`, `Cost` |
\\
***
## **Important variable details**
* MCC ID → manager account
* Account ID → specific ads account
Both are required to properly access the data.
* Defines the analyzed period:
* `7` → last week
* `30` → last month
* `90` → more strategic view
* The step can work in two ways:
* With a new defined budget
* With a percentage adjustment
This enables strategies such as:
* increasing 20% on high-performing campaigns
* automatically redistributing budget
### Practical examples
**1. Automatic media optimization**
* campaigns with higher ROAS receive more budget
* underperforming campaigns lose investment
**2. Automated marketing report**
Prompt:\
"Analyze CPA trends and identify the main deviations."
**3. Discovering new opportunities**
* search term analysis
* identify high-potential keywords
**4. Campaign audit**
* identify wasted budget
* find bottlenecks
Best practices
* Always validate MCC and Account ID
* Use consistent periods (e.g., 30 days)
* Avoid mixing very different campaigns in the same analysis
* Define clear KPIs: avoids generic analysis
* Be careful with Budget Shift: direct impact on investment
### Important notes
* Google Ads integration is required
* Account permissions are necessary
* Data depends on account structure
* Budget Shift impacts real investment
* Results vary depending on data volume
Google Ads within Tess turns your agent into a paid media analyst and optimizer. It enables identifying patterns, generating insights, and even automatically adjusting budgets, bringing more efficiency and scale to marketing operations.
# AI Step | Google Calendar
Source: https://docs.tess.im/en/google-calendar
The Google Calendar step connects your agents directly to Google Calendar, allowing them to list events within a time range or automatically create new events. With it, Tess performs real actions in your calendar without manual intervention.
### **What is this Step?**
This integration provides two actions within AI Studio:
* Get Events: Reads events from a specific time range in the calendar and brings this information into the agent’s context.
* Create Event: Creates a new event in the calendar with full details: title, description, date, time, guests, and notifications.
### **How Steps work in Tess: read before configuring**
This is the most important point to use the integration correctly: All App Integration steps run before any interaction with the user.
This means that when a user opens the chat and starts talking to the agent, the steps have already been executed. Therefore, the agent cannot:
* Wait for user approval to create the event
* Use information provided mid-conversation to trigger the step
What the agent can do:
1. Use User Inputs that were filled before the conversation started
2. Use pre-configured fixed information in the step
3. Use User Decision, which also collects the required data before the conversation
### **Practical summary:**
| **Scenario** | **Works** |
| ----------------------------------------------------------------- | --------- |
| Step creates event with User Inputs data (filled before the chat) | YES |
| Step creates event with fixed URL or configured data | YES |
| Step waits for user approval in chat to act | NO |
| Step uses a response given mid-conversation to create an event | NO |
### **Where to find it**
1. Go to AI Studio
2. Click Add AI Step
3. In Select Step Category, choose App Integration
4. In Choose an App, select Google Calendar
5. In Select Step Type, choose Create Event or Get Events
### **How to use (Quickstart)**
Action: Create Event
Configure the following fields:
| **Field** | **What to fill in** |
| :-------------------------- | :------------------------------------------------------------ |
| **Step Name** | Internal name of the step (e.g., `Create onboarding meeting`) |
| **Event Title** | Event title (e.g., variable `{{nome_cliente}}`) |
| **Event Description** | Meeting agenda or description |
| **Start Date / Start Time** | Start date and time (DD/MM/YYYY and HH:MM) |
| **End Date / End Time** | End date and time |
| **Timezone** | Time zone (e.g., `UTC-03:00` for Brasília) |
| **Send Notifications** | `Yes` to send email invites to participants |
| **Calendar Owner Email** | Email of the Google account that will receive the event |
| **Guest Emails** | Guest emails separated by commas |
**NOTE:**
All fields marked with User Decision can be dynamically filled via inputs or fixed in the step configuration.
Action: Get Events
Configure the following fields:
| **Field** | **What to fill in** |
| :----------------------- | :-------------------------------------------------------- |
| **Step Name** | Internal name of the step (e.g., `Fetch weekly schedule`) |
| **Start Date** | Start date of the period to query |
| **End Date** | End date of the period |
| **Timezone** | Calendar time zone |
| **Calendar Owner Email** | Email of the calendar to be queried |
The events found in this period will be available in the agent’s context to be used in the response or in other steps.
### **Deeper explanation**
Since steps run before the conversation, the usage logic changes. The agent does not create events “mid-conversation” — it starts the conversation with the event already created (or with the data already collected).
The correct design is:
```text theme={null}
User Inputs (collected beforehand)
↓
Step is executed
(Create Event or Get Events)
↓
Agent starts the conversation
already with the event created or
with the calendar data
```
**Combining Get Events + Create Event:**\\
If you want an agent that “checks the calendar and schedules the best time,” ideally both steps should run in sequence with predefined data — for example, fetching the current week’s events and then creating an event in the first available slot.
This type of logic works well in Text Agents triggered programmatically or via integration with another platform (e.g., Zapier, Make, or N8N).
***
### **Practical examples**
* The user fills in the data at the beginning (User Inputs): name, email, available date and time.
* The Create Event step uses these variables and creates the event before the chat starts.
* The agent opens the conversation already confirming: "Hello! Your onboarding meeting has been scheduled for \[date] at \[time]. Here's what we’ll cover..."\_
* A Text Agent is automatically triggered (via Make, for example) every morning.
* The Get Events step fetches all events of the day.
* The agent generates a structured summary of the schedule and sends it via email or Slack to the user.
* Integration via N8N or Zapier triggers the Tess Text Agent with form data as inputs.
* The Create Event step creates the event and sends the invite automatically.
* No human interaction is required in the process.
**Best practices**
* User Inputs are your allies: Whenever event data is variable (name, date, email), create a corresponding User Input and map it in the step.
* User Decision is for simple cases: Use it when the user needs to provide the data before the agent starts — ideal for Text Agents.
* Always define the Timezone: Events without the correct time zone may be created at the wrong time, especially if the calendar is in another state or country.
* Separate emails correctly in Guest Emails: No spaces after commas. Example: `{{email_cliente}},name@company.com`
* Name your step clearly: With multiple steps in the agent, clear names prevent confusion during maintenance.
### Pay attention to the following points:
* Mandatory authentication: Google Calendar must be integrated with your Tess account before using the step.
* The step always runs: Regardless of the conversation context, the step will execute when the agent starts. Ensure input data is always available.
* Credit consumption: Each step execution consumes credits from your plan.
Google Calendar turns Tess into an intelligent scheduling engine — but the key is understanding when it acts. With the right data available before the conversation begins, your agent creates events, reads schedules, and confirms meetings without any manual intervention.
# Google Drive
Source: https://docs.tess.im/en/google-drive
Connect Google Drive to Tess to find, organize, and work with files from chat and agents.
The **Google Drive** connector integrates Tess with Google Drive storage. Once connected, the AI can search files and folders, help organize content, and support document workflows inside chats and agents.
Google Drive is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A Google account with access to the Drive files/folders you need.
* Permission to authorize Google Drive OAuth scopes for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **Google Drive** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **Google Drive** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search files and folders** by name, type, or location
* **Summarize and locate documents** relevant to a task
* **Create folders and organize files** when the account has write access
* **Support sharing workflows** within the permissions of the connected account
* **Work across My Drive and accessible shared drives**
## Example prompts
> 1. Find the latest proposal PDF about Acme and summarize the commercial terms.
> 2. List files modified in the last 7 days in the Marketing folder.
> 3. Create a folder named 'Q3 Launch' and tell me where it was created.
> 4. Locate the onboarding checklist and outline the missing steps.
## Best practices
* Prefer folder or file names that are unique enough to avoid ambiguity.
* Ask before destructive actions like permanent deletes.
* In agents, define whether Drive is for search-only or also file organization.
## Troubleshooting
Reconnect Drive and confirm the Google account can grant the requested access. Workspace policies may block the app.
Reconnect Google Drive in Connectors after credential or admin policy changes.
Confirm the connected account can access that item (including shared drives).
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# AI Step | Google Slides
Source: https://docs.tess.im/en/google-slides
The Google Slides step allows your agent to rewrite and adapt entire presentations autonomously. Through the use of artificial intelligence (LLM), Tess reads the current content of a slide deck and replaces it with new text based on the instructions in your prompt, saving hours of work in customizing commercial proposals or training materials.
### **What it is**
The integration features a super-powerful action called Replace Content Using LLM.
In practice, the agent:
1. Accesses the URL of the provided presentation.
2. Analyzes the existing text on all slides.
3. Processes a prompt (guideline) defining the new theme or context.
4. Overwrites the old text with the new content generated by the AI, keeping the original design and text boxes intact.
### Golden Rule of Steps
Remember: This step runs BEFORE the interaction with the user.\
This means the presentation will already be altered before the chat begins. To work perfectly, the URL and Prompt must come from previous User Inputs, from an activated User Decision key, or be pre-configured in the step.
### Where to find it
1. Go to AI Studio.
2. Click on Add AI Step.
3. In Select Step Category, select App Integration.
4. In Choose an App, choose Google Slides.
5. In Select Step Type, choose Replace Content Using LLM.
### **How to use (Quickstart)**
To configure the smart replacement, you will need to fill in the following fields:
* Step Name: Internal name of your step (e.g., `Adapt Pitch Deck`).
* Google Slides URL: The full link of the presentation that will be modified (e.g., `https://docs.google.com/presentation/d/...`).
* Presentation Theme Prompt: The command that will guide the AI in the rewrite. This is where the brain of the operation lies.
* *Example:* "Rewrite this presentation about renewable energy focusing 100% on solar energy for the state of Minas Gerais. Include local economic benefits."
***Tip:***
*You can activate the User Decision key in any of these fields so the agent collects this information from the user before executing the action*
### **Design vs. Text**
It is fundamental to understand how Tess manipulates the slides:
* What it DOES: Replaces titles, bullet points, and paragraphs by structuring the new message in the same space.
* What it DOES NOT DO: Does not create new slides from scratch, does not delete slides, does not alter background images, colors, fonts, or the design structure.
The intelligence works exclusively with the text boxes. Therefore, the ideal scenario is to have a visually ready "Template", whose texts serve as markers for the AI to do the heavy lifting of copy adaptation.
***
### Practical examples
**Use Case 1: Commercial Proposal Machine**
* Previous action: Your system (e.g., Make/N8N) duplicates a generic "Sales Template" and generates a new URL for a specific client.
* The Step: The Tess agent takes this new URL, receives the Inputs for company name and sector, and applies them in the *Presentation Theme Prompt* field: `"Rewrite this pitch deck adapting the language for the {{Setor_do_Cliente}} sector and mention the company {{Nome_da_Empresa}} in the value propositions."`
* Result: The sales representative receives a 100% personalized deck ready to send, with zero manual effort.
**Use Case 2: Adaptation of Classes and Training**
* The Step: You provide the URL of a "Time Management" training that was made for the IT department.
* The Prompt: `"Rewrite all practical examples and tips from this presentation so they apply to the reality of a Customer Success team that handles daily tickets."`
***
**Best practices**
* Be careful with Original Templates: The *Replace Content* step overwrites the file from the provided URL. Never put the URL of your "Untouchable Official Template", otherwise, the AI will alter it directly. Always work with links of presentation copies.
* Directional Prompts: Be clear in the *Presentation Theme Prompt* field. The more specific the request (e.g., "keep the formal tone, list 3 advantages instead of long bullets"), the better the text will fit into the slide's original boxes.
* Combined User Inputs: Pass user variables (like `{{nome}}`, `{{desafio}}`) into the step's Prompt, to ensure extreme personalization.
### Important notes
* Authentication: Your Google account must be integrated into your Workspace settings in Tess AI.
* Edit Permission: The authenticated email in Tess needs to have *Editor* permission on the provided Google Slides URL, otherwise the step will fail.
* Credit Consumption: Reading an entire presentation and formulating a rewrite consumes a considerable amount of the LLM's context (tokens), impacting the credit balance. Caution is recommended with slides containing dozens of pages full of raw text.
With the Google Slides step, Tess AI ceases to be just a continuous text writer and starts acting as a presentation analyst. It is the perfect bridge to scale the creation of proposals and corporate materials, keeping your design standard untouched.
# HubSpot
Source: https://docs.tess.im/en/hubspot
Connect HubSpot to Tess to work with CRM contacts, deals, and pipeline context from chat and agents.
The **HubSpot** connector integrates Tess with HubSpot CRM. Once connected, the AI can look up contacts and companies, follow deals, and support sales or success routines inside chats and agents.
HubSpot is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A HubSpot account with access to the portal/data you need.
* Permission to authorize the HubSpot app for that portal.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **HubSpot** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **HubSpot** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Search contacts, companies, and deals** in your CRM
* **Summarize pipeline status** and next steps for opportunities
* **Create or update CRM records** when the account has write access
* **Support follow-ups** with context from notes, properties, and deal stages
* **Help sales and CS teams** act without switching tools
## Example prompts
> 1. Find the HubSpot deal for Acme and summarize stage, amount, and next step.
> 2. List contacts created this week with no owner assigned.
> 3. Update the Acme deal note with today's discovery call summary.
> 4. Which open deals are stuck in Negotiation for more than 14 days?
## Best practices
* Name the company/deal clearly to avoid duplicates.
* Ask for confirmation before updating CRM fields.
* In agents, define whether HubSpot is for lookup, pipeline reporting, or CRM updates.
## Troubleshooting
Confirm you are authorizing the correct HubSpot portal and that your role can grant app access.
Reconnect HubSpot in Connectors after password or permission changes.
The connected user may lack permission on that object. Use an account with the required CRM scopes.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# Image Generator
Source: https://docs.tess.im/en/image-gen
Tess's Image Generator is the dedicated environment for generating images using all the models available on the platform. Here, you transform text descriptions (prompts) into unique and personalized images.
You can create everything from ultra-realistic photographs to artistic illustrations, logos, graphics, and concept art — all without relying on generic stock image libraries.
### **You can generate images in three ways on Tess AI:**
For this option, go to Agent Studio in the left side menu and then select Image Generator.
Here, after opening the chat, activate the Images tool in the Tools menu and request image generation in natural language.
After creating an agent specialized in generating images with a fixed style, format, and rules. Ideal for maintaining visual consistency across series (posts, ads, banners).
**What is it and how to use the Image Generator**
In this article, we will focus on image generation in the Generator, whose interface will work as your digital art studio within Tess AI. In it, you describe what you want to see, choose the AI model, adjust technical details (aspect ratio, resolution, style), and generate the image.
To work with image generation in the Generator, think carefully about the prompt, the model to be used, and the other advanced settings, which vary depending on the chosen model.
This is the heart of AI image creation. The prompt is where we describe, in as much detail as possible, the image we want to generate. The more specific, the better — the AI creates the image based on the composition elements of each description.
Think about elements such as:
* Subject: who or what is the main focus? E.g.: "a vintage robot made of rusty metal"
* Action: what is the subject doing? E.g.: "reading a book lit by a candle"
* Setting: where does the scene take place? E.g.: "in an old and dusty library, with tall bookshelves"
* Style and atmosphere: what is the aesthetic? E.g.: "oil painting, dramatic lighting, baroque style"
* Technical details (when applicable): camera angle, lighting, composition. E.g.: "close-up, soft side lighting, shallow depth of field"
Full prompt example:
> "Ultra-realistic photograph of a cozy café in Paris on a rainy day. The window is fogged with raindrops, and through it the Eiffel Tower can be seen in the background. Inside, a cappuccino with latte art sits on a rustic wooden table. Warm and soft lighting, intimate atmosphere."
**Tip:** Take advantage of the Magic Prompt feature to enhance your prompt and translate it to English (which performs better) — after all, there is no LLM to support you here, unlike what happens in the chat!
In addition to the prompt, it is important to choose a model that will be responsible for generating your image. In Tess AI, we have a list with dozens of available models, each with its own training and strong results for different image contexts.
To explore the options and search for one, you can type the name or scroll down:
Each model has its own characteristics — some are better for photographic realism, others excel in fantasy art, illustration, or artistic style, and some offer greater technical control (pose, composition, details).
The best way to find out which one works best for you is to experiment or check the specifications of each one on their official release pages.
Each model provides some advanced configuration options, so when you expand this section in the image generator you will see options that vary and overlap between models. The main settings are:
* Aspect ratio: square, portrait, landscape, widescreen
* Resolution: defines quality and file size
* Seed: to reproduce or iterate over a specific image
In some cases, you will also see the negative prompt option. Just as important as the main prompt, the negative prompt is used to refine the result by eliminating unwanted elements.
Use it to avoid:
* Styles you don't want. E.g.: "cartoon, 3D render, vector illustration"
* Quality issues. E.g.: "low resolution, blurry, deformed, distorted, artifacts"
* Unwanted visual elements. E.g.: "text, watermark, signatures, frames"
* Specific colors or objects. E.g.: "green tones, people in the background"
### Done!
Once everything is configured, just click to generate, view the results, and refine the parameters!
You will see the credit consumption next to the generate button!
Your first image may not be perfect — use it as a starting point. Then adjust the main prompt, generate variations, and combine with post-processing (upscale, editing, background removal).
The Image Generator opens a creative universe of virtually unlimited possibilities. Whether you want to create content for social media, illustrate an article, develop visual concepts, or simply bring your imagination to life, this tool puts the power of a design studio directly in your hands — guided only by your description and creativity.
# How It Works: User Inputs
Source: https://docs.tess.im/en/inputs
When building an agent in Agent Studio, you may also want it to perform the same task but with different information each time. That is what User Inputs are designed to support you with.
Unlike a fluid conversation in a chat agent with static training, User Inputs are pre-defined configuration fields that need to be filled in to start using the agent.
### **What are User Inputs?**
Think of them as the fields of a form that you create for your agent. Instead of writing a long and detailed prompt with multiple scenarios, you guide the user and ask them to provide essential and specific information that the agent needs to complete its training and start working.
In other words, these inputs are variables that complement the agent's training. But keep in mind — they do not appear throughout the use of the agent, since they are the initial condition for it to begin.
### **The Available Input Types**
You can request information from the user in several structured ways:
* Short Text: For requesting brief and direct information. Ideal for names, titles, numbers, or keywords.
* Long Text: Allows the user to enter large blocks of text. Perfect for descriptions, articles to be summarized, or detailed instructions.
* **Single Selection (Dropdown):** Presents a list of options where the user can only choose one. Great for limiting the response to a specific scenario.
* Multiple Selection (Checkboxes): Offers a list of options where the user can check several. Excellent for capturing preferences or multiple interests.
* File Upload: Allows the user to attach a file (such as audio, video, or a document). This input type is especially powerful when connected to an Advanced Step (such as audio transcription or PDF text extraction) to process the file before the AI uses the information.
### **Example: The "Mad Libs" Agent**
Imagine you created an agent to write thank-you emails. The body of the email will always be similar, but the customer's name and the product they purchased change each time.
> Instead of teaching the agent to write: "Write a thank-you email to the customer \[NAME] who purchased the product \[PRODUCT]", you can create two User Inputs: customer\_name and purchased\_product.
When a user goes to use your agent, they will not see an empty chat, but rather two fields to fill in. Only after filling them in and clicking "Run" will the agent start its task, already equipped with that information and replacing the variables in the training.
### **How It Works in Practice**
When building the agent, you will define the User Inputs your agent needs (e.g.: company\_name, target\_audience, output\_language).
After that, you need to insert these inputs as variables — because if you don't reference the input in the prompt, it won't be taken into account anywhere.
The variable part of your prompt could be:
> "With these guidelines in mind, now create an Instagram post for the company company\_name, focused on the target\_audience. The text must be in output\_language."
**For the agent user:**
When selecting the agent, an interface with the fields "Company Name", "Target Audience", and "Output Language" appears. The user then fills in these fields and submits.
The agent, behind the scenes, inserts the filled-in information into the prompt and finalizes the training with that new context.
### **Main Advantages**
Makes a generic agent applicable to infinitely specific scenarios.
The end user does not need to learn how to write complex prompts. They simply fill in a straightforward form.
Ensures the AI always receives crucial information in the format you defined, avoiding errors and ambiguities.
User Inputs are the best way to turn a powerful prompt into a user-friendly and reusable tool. In addition, they can also be used as input in advanced steps!
They are the bridge between the complexity of your AI training and the simplicity your end user needs to be productive.
# Link Files to Agent
Source: https://docs.tess.im/en/link-files
POST https://api.tess.im/agents/{agentId}/files
Link a file to be associated with a specific agent.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{agentId}/files' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
-H 'Content-Type: application/json' \
-d '{
"file_ids": [
fileId1,fileId2
]
}'
```
```json Node.js theme={null}
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const form = new FormData();
form.append('file', fs.createReadStream('/path/to/file'));
const config = {
method: 'post',
url: 'https://api.tess.im/agents/{agentId}/files',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
...form.getHeaders()
},
data: form
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/{agentId}/files"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
files = {
'file': open('/path/to/file', 'rb')
}
response = requests.post(url, headers=headers, files=files)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/{agentId}/files",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
],
CURLOPT_POSTFIELDS => [
'file' => new CURLFILE('/path/to/file')
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.io.File;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
File file = new File("/path/to/file");
String boundary = "---boundary" + System.currentTimeMillis();
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{agentId}/files"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json; boundary=" + boundary)
.POST(HttpRequest.BodyPublishers.ofByteArray(Files.readAllBytes(file.toPath())))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"mime/multipart"
"net/http"
"os"
)
func main() {
file, err := os.Open("/path/to/file")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("file", file.Name())
if err != nil {
fmt.Println(err)
return
}
_, err = io.Copy(part, file)
if err != nil {
fmt.Println(err)
return
}
writer.Close()
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/agents/{agentId}/files", body)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", writer.FormDataContentType())
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(respBody))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
using (var formData = new MultipartFormDataContent())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var fileContent = new ByteArrayContent(System.IO.File.ReadAllBytes("/path/to/file"));
formData.Add(fileContent, "file", "filename");
try
{
var response = await client.PostAsync("https://api.tess.im/agents/{agentId}/files", formData);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/{agentId}/files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
form_data = [['file', File.open('/path/to/file')]]
request.set_form form_data, 'application/json'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the agent
### **Body Parameters**
The file IDs to link to the agent
### **Response**
```json theme={null}
{
"id": 8794,
"files_count": {
"total": 1,
"completed": 1,
"failed": 0,
"in_progress": 0
},
"files": [
{
"id": 73336,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:39:57+00:00",
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
}
],
"status": "completed"
}
```
# LinkedIn
Source: https://docs.tess.im/en/linkedin
Connect LinkedIn to Tess to support professional research and content workflows from chat and agents.
The **LinkedIn** connector integrates Tess with LinkedIn. Once connected, the AI can help with professional research and content-related tasks inside chats and agents, within the permissions of the connected account.
LinkedIn is part of the Tess [Connectors](/en/connectors) ecosystem and uses **OAuth** authentication for Apps connectors.
## Prerequisites
* A LinkedIn account with access to the data or pages you need.
* Permission to authorize the LinkedIn app for that account.
## How to connect
On some Apps connectors, the OAuth consent screen may show a third-party connection bridge name rather than Tess. That is normal—review the requested permissions and continue if they match what you expect.
In chat, click the **+** next to the message box and select **Connectors**.
You can also manage connectors while editing an agent in Agent Studio.
Under **Apps**, locate **LinkedIn** and click **Connect** to start authentication.
Sign in with the account you want to use and review the requested permissions before confirming.
Back in Tess, **LinkedIn** should appear under **Connected**, ready for chats and agents.
## What you can do
* **Support professional research** for people, companies, or topics you can access
* **Help draft posts and updates** for review before publishing
* **Summarize public professional context** relevant to a go-to-market task
* **Assist recruiting or sales prep** with clearer briefing notes
* **Keep LinkedIn workflows closer to Tess**
## Example prompts
> 1. Draft a LinkedIn post announcing our new Connectors docs and keep it under 1200 characters.
> 2. Prepare a short brief about Company X for an outbound sales call.
> 3. Suggest 5 post angles about AI agents for operations leaders.
> 4. Summarize the key talking points I should use when engaging prospects in SaaS.
## Best practices
* Be explicit about audience and tone for drafts.
* Ask for a preview before publishing anything.
* In agents, define whether LinkedIn is for research, drafting, or both.
## Troubleshooting
Reconnect with the LinkedIn account that has the needed access and approve the requested permissions.
Reconnect LinkedIn in Connectors after password or app permission changes.
Some LinkedIn data is restricted by account type or permissions.
Tess uses the permissions of the connected account. It does not expand access beyond what that account can already do.
Connectors involve access to external systems. Only connect accounts that fit the usage context, and review permissions carefully.
# List Agent Files
Source: https://docs.tess.im/en/list-agent-files
GET https://api.tess.im/agents/{agentId}/files
Retrieve a list of files associated with a specific agent.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents/{agentId}/files' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents/{agentId}/files',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/{agentId}/files"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/{agentId}/files",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{agentId}/files"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents/{agentId}/files", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents/{agentId}/files");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/{agentId}/files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the agent
### **Response**
```
{
"id": 8794,
"files": [
{
"id": 73336,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:39:57+00:00",
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
}
],
"status": "completed"
}
```
# List Agent Versions
Source: https://docs.tess.im/en/list-agent-versions
GET https://api.tess.im/agents/{id}/versions
Returns a paginated list of all saved versions for a specific agent, including a field-level diff and `change_summary` for each version relative to the previous one. Requires the `agent:version:read` permission.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents/8794/versions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents/8794/versions',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/8794/versions"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/8794/versions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/8794/versions"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents/8794/versions", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents/8794/versions");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/8794/versions')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
### **Query Parameters**
Current page (default: 1)
Number of items per page (default: 20)
### **Response**
```json theme={null}
{
"versions": [
{
"version_id": 9,
"published_at": "2026-04-09T14:30:00+00:00",
"published_by": "user@example.com",
"rollback_from_version": 5,
"change_summary": "",
"diff": []
},
{
"version_id": 7,
"published_at": "2026-04-06T13:52:19+00:00",
"published_by": "user@example.com",
"rollback_from_version": 2,
"change_summary": "instructions, ask_user_questions",
"diff": {
"instructions": {
"previous_version": "You are a helpful assistant.",
"current_version": "You are a helpful customer support assistant."
},
"ask_user_questions": {
"previous_version": [],
"current_version": [
{
"name": "topic",
"type": "text",
"description": "What topic do you need help with?",
"required": true,
"tooltip": ""
}
]
}
}
},
{
"version_id": 1,
"published_at": "2026-04-02T17:52:17+00:00",
"published_by": "user@example.com",
"rollback_from_version": null,
"change_summary": "",
"diff": []
}
],
"current_version_number": 9,
"meta": {
"total": 9,
"page": 1,
"per_page": 20
}
}
```
### **Response Fields**
| **Field** | **Type** | **Description** |
| :----------------------- | :--------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| versions | array | List of version entries for this agent |
| current\_version\_number | integer | The `version_id` of the currently active version |
| meta.total | integer | Total number of versions |
| meta.page | integer | Current page number |
| meta.per\_page | integer | Number of items per page |
| version\_id | integer | Unique sequential identifier for this version |
| published\_by | string | Email of the user who saved this version |
| published\_at | string (ISO8601) | Timestamp when this version was created |
| rollback\_from\_version | integer \| null | If this version was created by a rollback, the source `version_id`; otherwise `null` |
| change\_summary | string | Comma-separated list of field names that changed relative to the previous version. Empty string when nothing changed |
| diff | object \| array | Field-level diff vs. the previous version. Each key contains `previous_version` and `current_version`. Returns an empty array `[]` when there are no changes |
# List Agent
Source: https://docs.tess.im/en/list-agents
GET https://api.tess.im/agents
Lists all agents with support for searching, filtering, and pagination.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Query Parameters**
Search agents by title, description and long description
Filter by agents type (chat, image, text, video)
Current page (default: 1)
Number of items per page (default: 15)
### **Response**
```json theme={null}
{
"current_page": 1,
"data": [
{
"id": 8794,
"title": "Tess AI - API Docs Helper",
"description": null,
"long_description": null,
"workspace_id": 11,
"visibility": "public",
"slug": "tess-ai-docs-helper-pB9ujA",
"active": 1,
"type": "chat",
"questions": [
{
"type": "select",
"name": "temperature",
"description": "Let Tess know if you want her to be more objective or more creative with her responses.",
"required": true,
"options": [
"0",
"0.25",
"0.5",
"0.75",
"1"
]
},
{
"type": "select",
"name": "model",
"description": "Choose the Model version",
"required": true,
"options": [
"gpt-4o-mini",
"gpt-4o",
"tess-5",
"tess-ai-3",
"gpt-o1-preview",
"gpt-o1-mini",
"gemini-2.0-flash",
"gemini-1.5-flash",
"gemini-1.5-pro",
"claude-3-5-haiku-latest",
"claude-3-5-sonnet-20240620",
"claude-3-5-sonnet-latest",
"claude-3-opus-20240229",
"meta-llama-3.1-405b-instruct",
"meta-llama-3-70b-instruct",
"meta-llama-3-8b-instruct",
"cohere-command-r",
"cohere-command-r-plus",
"gpt-3.5-turbo",
"gpt-4-turbo",
"claude-3-haiku-20240307",
"claude-3-sonnet-20240229",
"gemini-1.0-pro",
"llama-2-13b-chat",
"llama-2-70b-chat"
]
},
{
"type": "select",
"name": "tools",
"description": "Choose the Model version",
"required": true,
"options": [
"no-tools",
"internet",
"twitter",
"wikipedia",
"quora",
"reddit",
"medium",
"linkedin",
"instagram",
"facebook"
]
},
{
"type": "number",
"name": "root_id",
"description": "The stored session id to continue conversation.",
"required": false
},
{
"type": "array",
"name": "messages",
"description": "The list of messages in the chat history. Use a list of objects with role and content, same as OpenAI API.",
"required": true
}
],
"created_at": "2025-01-05T18:09:18.000000Z",
"updated_at": "2025-01-05T18:45:31.000000Z",
"created_by": 13
}
],
"first_page_url": "https://api.tess.im/agents?page=1",
"from": 1,
"last_page": 1,
"last_page_url": "https://api.tess.im/agents?page=1",
"links": [
{
"url": null,
"label": "pagination.previous",
"active": false
},
{
"url": "https://api.tess.im/agents?page=1",
"label": "1",
"active": true
},
{
"url": null,
"label": "pagination.next",
"active": false
}
],
"next_page_url": null,
"path": "https://api.tess.im/agents",
"per_page": 15,
"prev_page_url": null,
"to": 1,
"total": 1
}
```
# AI Step | Marker Document Processing
Source: https://docs.tess.im/en/marker-document-processing
The Marker Document Processing step converts complex files (PDF, DOCX, PPTX, images, etc.) into structured Markdown, preserving content organization. It is ideal for transforming rich materials into clean, usable data for AI agents.
### What is the Step?
This step acts as a universal document converter, translating different formats into structured text.
In practice, it:
* Reads files such as PDFs, Word documents, presentations, and images
* Interprets structure (headings, lists, tables, etc.)
* Converts everything into Markdown
* Delivers organized content ready for AI use
Unlike other steps:
* It does not generate only raw text
* It preserves the document’s logical structure
### Where to find it
1. Go to AI Studio
2. Click on Add AI Step
3. Select Document Processing
4. Choose Marker Document Processing
***
## How to use?
### Configuration fields
| Field | Required | Description |
| :-------------- | :------- | :--------------------------------------------------------------------------------- |
| Step Name | Yes | Internal step name (alphanumeric). Used as a reference in the agent |
| File URL | Yes | Direct file URL (must end with extension: `.pdf`, `.docx`, `.jpg`, etc.) |
| Processing Mode | Yes | Defines quality vs speed: `Fast`, `Balanced`, `Accurate` |
| Use LLM | No | `Yes/No`. Improves accuracy (tables, layout, forms), but increases processing time |
| Max Pages | No | Maximum number of pages to process |
| Page Range | No | Page interval (e.g.: `0,2-4`) |
**Important configuration rules**
* Max Pages and Page Range are mutually exclusive
* File URL must be direct (cannot be a preview page)
* Use LLM increases cost and processing time
## Deeper explanation
This step works as a document translator into structured language (Markdown).
Document (PDF, DOCX, image...) → Step interprets structure
↓
Converts to Markdown → Agent receives organized content
### Markdown vs plain text
Practical comparison:
* Extract Text (DOCX, TXT, etc.) → raw linear text
* Marker Document Processing → structured text (with hierarchy)
Example:
`# Title`
`## Subtitle`
`- Item 1`
`- Item 2`
`| Column A | Column B |`
`|----------|----------|`
## Practical examples
* PDFs, presentations, and e-books
* Convert everything to Markdown
* Use as a base for content generation
* Process contracts or proposals
* Enable Use LLM for better table reading
* Extract:
* values
* deadlines
* clauses
* PDFs, images, DOCX
* Standardize everything into Markdown
* Agent compares with job requirements automatically
* Internal documents → Markdown
* Feed support or FAQ agents
Prompt:\
"Extract all tables and organize the data into a structured format."
**Best practices**
* Use “Balanced” as default: best cost-benefit, but evaluate if it’s the best result for your case
* Use more robust LLMs for complex documents, especially: tables, forms, and broken layouts
* Use Page Range for large documents: avoids unnecessary consumption
* Ensure direct URLs: e.g., `.pdf`, `.docx` (not Google Drive preview)
* Combine with other steps: Marker → analysis → save to Drive/Sheets
## Important notes
* Links requiring login or preview pages do not work
* Use LLM increases time and cost
* Large files impact performance
* Structure is preserved, but not perfect in all cases
Marker Document Processing is the most powerful step for handling complex documents. By converting multiple formats into structured Markdown, it enables AI agents to work with organized data while preserving context and hierarchy — essential for more accurate analysis and robust automations.
# AI Step | Media Converter
Source: https://docs.tess.im/en/media-converter
The Media Converter step allows you to convert audio and video files between different formats directly within Tess. It ensures compatibility across platforms, reduces file size, and enables transformations such as extracting audio from video.
### What is the Step?
Media Converter acts as a universal media converter, integrated into the agent workflow.
In practice, it:
* Receives an audio or video file via URL or from a previous step
* Converts it to a new format
* Returns a URL of the converted file
This enables automating multimedia processes without relying on external tools.
### Where to find it
1. Go to AI Studio
2. Click on Add AI Step
3. Select Document Processing
4. Choose Media Converter
***
## How to use?
### Configuration fields
| Field | Required | Description |
| :--------- | :------- | :-------------------------------------------------------------------------- |
| Step Name | Yes | Internal step name (alphanumeric). Used as a reference in the agent |
| File URL | Yes | Direct URL of the audio or video file, or output variable from another step |
| Convert To | Yes | Desired output format (e.g.: `.mp3`, `.mp4`, `.wav`) |
## Supported formats
`.mp3`
`.wav`
`.aac`
`.flac`
`.ogg`
`.wma`
`.m4a`
`.opus`
`.mp4`
`.avi`
`.mkv`
`.mov`
`.wmv`
`.flv`
`.webm`
`.mpeg`
`.3gp`
`.ogv`
`.m4v`
### About the Output
The result is:
* A direct URL of the converted file
* Preserved content (same audio/video, new format)
* Ready for: download; sharing and/or use in other steps
### Deeper explanation
This step works as a media transformation stage within the workflow.
Original file (audio/video) → Format conversion
↓
New URL generated → Used in next steps
It does not analyze content — it only transforms the format.
## Practical examples
* Receive videos in `.mov` or `.mkv`
* Convert to `.mp4`
* Ensure compatibility with social platforms
* Convert `.mp4` → `.mp3`
* Use for:
* transcription
* internal podcasts
* training
* Convert `.avi` → `.mp4`
* Reduce size and improve compatibility
Example flow:
Video → Media Converter → MP3 → Transcription → Text
* Extract audio
* Generate automatic summaries with AI
**Best practices**
* Use standard formats: `.mp4` (video) or `.mp3` (audio)
* Ensure direct URLs: preview links may fail
* Combine with other steps: Media Converter → Transcription → Analysis
* Standardize formats in the workflow: avoids downstream issues
* Use clear Step Names: e.g., `video_to_mp3`
## Important notes
* The step does not analyze content, it only converts
* The URL must be public and accessible
* Large files may impact processing time
* Conversion quality may vary slightly depending on the format
Media Converter removes compatibility issues and prepares multimedia files for automation. It is essential for workflows involving audio and video, enabling you to transform, standardize, and chain media within Tess in a simple and scalable way.
# AI Step | Meta Ads
Source: https://docs.tess.im/en/meta-ads
The Meta Ads step allows your agents to analyze performance, identify wasted budget, and automatically redistribute investment across Facebook and Instagram campaigns. With this, Tess acts as a data-driven paid media optimizer.
### **What is the Step?**
The integration with Meta Ads provides 6 actions, divided into:
### Actions (execution)
* Change Campaign Daily Budget → changes the daily budget
* Change Campaign Status → enables or pauses campaigns
* Budget Shift Campaigns → automatically redistributes budget
### Analysis (insights)
* Creative Image Analysis → analyzes creatives (images)
* Identify Overactive Ads → identifies ad fatigue
* Metrics Trend Report → analyzes performance trends
## **How to use (Fields per action)**
### 1. Change Campaign Daily Budget
| Field | Description |
| :---------------------- | :--------------------------------------------------- |
| Step Name | Internal step name |
| Ad Account ID \* | Meta ads account ID |
| Campaign ID \* | Campaign ID to be changed |
| Budget Change Method \* | Method: `Set Exact Amount` or `Adjust by Percentage` |
| Budget Change Value \* | Change value (e.g.: `100.00`, `30`, `-20`) |
***
### 2. Change Campaign Status
| Field | Description |
| :--------------------- | :------------------------------ |
| Step Name | Internal step name |
| Ad Account ID \* | Ads account ID |
| Campaign ID \* | Campaign ID |
| New Campaign Status \* | New status (`ACTIVE`, `PAUSED`) |
***
### 3. Budget Shift Campaigns
| Field | Description |
| :--------------------------- | :---------------------------------------------------- |
| Step Name | Internal step name |
| Meta Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Analysis period (e.g.: `30`) |
| Has New Budget Allocation \* | Defines if there will be a new budget (`Yes` or `No`) |
| New Budget | New total value (e.g.: `2500.00`) |
| Percent Adjust | Percentage adjustment (e.g.: `20` or `20%`) |
| Excluded Campaigns ID | Excluded campaign IDs |
| Excluded Adsets ID | Excluded ad set IDs |
***
### 4. Creative Image Analysis
| Field | Description |
| :------------------------ | :----------------- |
| Step Name | Internal step name |
| Meta Ads Account ID \* | Ads account ID |
| Analysis Period (Days) \* | Period analyzed |
***
### **5. Identify Overactive Ads**
| Field | Description |
| :-------------- | :------------------------------------- |
| Step Name | Internal step name |
| Account ID \* | Account ID |
| Limit (Days) \* | Days limit to consider it "overactive" |
***
### 6. Metrics Trend Report
| Field | Description |
| :--------------------------------- | :--------------------------------------- |
| Step Name | Internal step name |
| Meta Ads Account ID \* | Account ID |
| Analysis Period (Days) \* | Period analyzed |
| Report Segment \* | Segment (e.g.: `campaigns`, `adsets`) |
| Key Performance Indicator (KPI) \* | Main metric (e.g.: `cpa`, `cpr`, `roas`) |
***
## Practical examples
* Automatically reduce budget on low-performing campaigns
* Identify saturated creatives
* Redistribute budget across campaigns
* Generate automatic performance reports
Best practices
* Always validate IDs
* Use consistent periods (e.g., 30 days)
* Define clear KPIs
* Be careful with budget automations
## Important notes
* Meta Ads integration is required
* Actions impact real campaigns
* There is no confirmation prior to execution
Meta Ads transforms Tess into a complete paid media operator, capable of analyzing, detecting issues, and executing optimizations automatically.
# AI Step | Microsoft
Source: https://docs.tess.im/en/microsoft
The Microsoft Excel step allows your agents to read data from spreadsheets and write new information directly into .xlsx files. With this, Tess can query operational databases, automatically populate spreadsheets, and integrate workflows that depend on structured data.
## **What is the Step?**
This integration connects Tess to the Microsoft ecosystem to perform actions on Excel files. Currently, the available actions are:
* Get Values: reads values from a spreadsheet
* Write Values: writes values to a spreadsheet
In practice, this allows Excel to be used as a query source or as an output destination for AI automations.
## **Where to find it**
1. Go to AI Studio
2. Click on Add AI Step
3. In Select Step Category, choose App Integration
4. In Choose an App, select Microsoft
5. In Select Step Type, choose:
* Excel Get Values
* Excel Write Values
## How do the steps work?
Important note: App Integration steps run before the user interaction.
This means that:
* the spreadsheet is read before the chat starts
* writing to the spreadsheet also happens before the conversation
* data must already be defined via:
* User Inputs
* User Decision
* Variables coming from external integrations
The step does not wait for a mid-chat response to then query or write to Excel.
## How to use (Quickstart)
### 1. Excel Get Values
Use this action to read data from a spreadsheet.
* Step Name: internal name of the step
* File Path: path to the Excel file (example: FolderName/FileName.xlsx or FileName.xlsx)
* Data Range: range or sheet to be read (example: Sheet1!A1:D4 or Sheet1)
1. Enter the file path
2. Define the sheet or range you want to work with in the Step
3. Save the step
4. The read values become available in the agent's context
The Path and Range fields can be specified by the user at the time of use — just select it as User Decision.
### 2. Excel Write Values
Use this action to write data to a spreadsheet.
* Step Name: internal name of the step
* File Path: path to the Excel file (example: FolderName/FileName.xlsx or FileName.xlsx)
* Cell Range: range where the data will be written (example: Sheet1!A1:D4)
* Data Values: matrix of values in list format (example: \[\["Col1","Col2"],\["Data1","Data2"]])
1. Enter the file path
2. Define the exact write range the Step will need to interact with
3. Fill in the values in the expected format
4. Save the step
5. The spreadsheet will be updated automatically
The Path and Range fields can be specified by the user at the time of use — just select it as User Decision.
How it works
## **What is each field?**
The File Path points to the Excel file that will be read or updated. It can be:
* just the file name, if it is at the root
* folder + file name, if it is inside a subfolder
Examples:
* Relatorio.xlsx
* Financeiro/Forecast.xlsx
* Operacao/Clientes/Base.xlsx
The range defines exactly where Tess will act.
Examples:
* Sheet1
* reads the entire sheet \[CONFIRM exact behavior]
* Sheet1!A1:D4
* reads or writes in the range between A1 and D4
In Write Values, data must be sent in a matrix structure.
Simple example:\
\[\["Name","Email"],\["Ana","[ana@company.com](mailto:ana@company.com)"],\["Bruno","[bruno@company.com](mailto:bruno@company.com)"]]
In practice:
* each inner list represents a row
* each item represents a cell
## Practical examples
### 1. Query a customer database
Action: Excel Get Values
Usage: the agent reads a spreadsheet with customer data before the conversation, then answers questions based on that information.
Example prompt:\
"Use the spreadsheet data to identify customers with renewals this month and summarize the key points."
### 2. Automatically register leads
Action: Excel Write Values
Usage: a form submits name, email, and company — and the step writes that data to the sales spreadsheet
Example Data Values:\
\[\["Name","[name@company.com](mailto:camy@empresa.com)","Tess AI"]]
### 3. Update internal controls
Action: Excel Write Values
Usage: populate an onboarding, support, or sales tracking spreadsheet. Ideal for teams that still run part of their processes through Excel
### 4. Read operational metrics
Action: Excel Get Values
Usage: pull data from a metrics spreadsheet and ask the agent to summarize bottlenecks, trends, or deviations.
Example prompt:\
"Analyze the spreadsheet data and highlight the 3 main operational alerts."
**Best practices**
* Define specific ranges: avoids excessive reading and writing outside the expected location
* Standardize sheet names: reduces configuration errors
* Review the Data Values format: it must be a valid matrix
* Use files organized by folder: makes step maintenance easier
* Test first on sample spreadsheets: especially for Write Values
## Important notes
* The Microsoft account must be integrated with Tess — this process is done before using the agent
* The user who will use the agent must have access permission to the file
* Incorrect writes can overwrite the wrong cells
* Very broad reads may bring more context than necessary
The Microsoft Excel step allows spreadsheets to become a query source and automation destination within Tess. When properly configured, it helps integrate AI with real operations, keeping structured data up to date without manual effort.
# AI Step | Microsoft OneDrive
Source: https://docs.tess.im/en/microsoft-one-drive
The Microsoft OneDrive step allows your agent to download files from both OneDrive and SharePoint using shared links. This makes it possible to use corporate documents as a basis for analysis, automation, and intelligent responses within Tess.
### **What is the Step?**
This integration allows the agent to access files hosted in the Microsoft ecosystem and bring that data into the context.
Available actions:
* Download OneDrive File → files via `1drv.ms` link
* Download SharePoint File → files via `sharepoint.com` link
Both work the same way: they download the file and make the content available to the agent.
## How to use (Quickstart)
### Download OneDrive File
Fields:
* Step Name
* Sharing URL \*\
Ex: `https://1drv.ms/...`
***
### **Download SharePoint File**
Fields:
* Step Name
* Sharing URL\
Ex: `https://company.sharepoint.com/...`
### How to configure the URL
You can use:
* Fixed URL - pre-configured in the step
* User Input (text field)
* User Decision (collected before execution)
Both steps work as external data inputs (file ingestion).
URL provided → File is downloaded
↓
Content enters the context → Agent uses it to respond or process
### **Practical examples**
**1. Corporate document analysis (SharePoint)**
* contract, proposal, internal policy
* agent extracts risks, clauses, or a summary
**2. Reading files sent by customers**
* customer shares a OneDrive link
* agent processes it automatically
**3. Dynamic knowledge base**
* use SharePoint files as an up-to-date source
* avoid manual RAG maintenance
**4. Processing commercial attachments**
* proposals, briefings, presentations
* transform into insights or structured data
***
**Best practices**
* Ensure correct permissions: especially in SharePoint (more restrictive)
* Use direct links: invalid or protected links may fail
* Standardize file sources: avoids inconsistency in the workflow
* Combine with clear prompts: defines what will be done with the content
## Important notes
* Microsoft integration is required
* SharePoint requires appropriate organization-level permissions
* The step only reads files (does not edit)
With support for OneDrive and SharePoint, this step allows your agents to work directly with real operational documents, whether at an individual or corporate level. This eliminates manual uploads and enables automations based on up-to-date files.
# AI Step | Google OCR PDF & Image
Source: https://docs.tess.im/en/ocr-pdf
This function allows you to extract text from PDF documents or images into readable text. Using advanced OCR (Optical Character Recognition) technologies, it is possible to accurately analyze and interpret the textual content of images and PDFs, even under low-quality conditions. And with the help of AI, you can train models to use this information as references to structure summaries, analyses, and strategic materials.
> \*\*Input Fields: \*\*PDF file upload - Upload the PDF or image you want to extract information from.
>
> \*\*Output Result: \*\*The extracted text will be presented in a typed format, with high fidelity to the original content.
### **Use Cases:**
Convert large volumes of paper-archived documents into digital formats, making it easier to access and search for information. With the help of AI, you can prepare summaries and obtain analyses of these materials.
Use AI to extract terms and conditions from contracts stored in PDF, integrating them into contract management systems and even creating methodologies for contract comparison and fraud detection. In this case, the content can be screenshots, for example.
Insurance companies can implement AI for OCR to quickly digitize and process claims documents, speeding up response time and improving customer satisfaction.
With this step you can extract any information and data contained in images and, with the help of AI models, you can prepare summaries, structure insights, and use the extracted text for any necessary analysis.
**Limitations:**
* The conversion quality may vary depending on the quality of the original document and the complexity of the layout.
* Training cannot exceed the token limit of the selected LLM. This can range from 10,000 to 140,000 words. Therefore, make sure the selected PDF is within this limit. If you have a PDF that exceeds the limit, consider splitting it into smaller parts.
The Google OCR PDF & Images function offers a powerful and efficient solution for transforming physical or digital documents into editable text, using artificial intelligence to ensure accuracy and ease of integration with other digital systems.
This tool is essential for organizations looking to improve document management and information accessibility, where in addition to extraction, you can create summaries and use the result as a reference for producing new materials or documenting internal processes, with the help of AI.
# Execute OpenAI Compatible
Source: https://docs.tess.im/en/open-ai-compat
api-reference/agents-execution.openapi.json POST /agents/{id}/openai/chat/completions
Execute a specific **chat** agent by ID using the OpenAI-compatible API.
### **Code Examples**
See the [OpenAI SDK](https://platform.openai.com/docs/libraries) documentation for more info. At the moment, our API only support the `temperature` and `messages` (roles `system`, `user` and `assistant`) model parameters. Additionally, the `tools` parameter is a `string` enum. To verify the model parameters of an specific agent, see the [Get Agent](https://docs.tess.im/en/get-agent) endpoint.
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{id}/openai/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"temperature": "1",
"model": "tess-5",
"messages": [{ "role": "user", "content": "hello there!" }],
"tools": "no-tools",
"stream": true
}'
```
```json Node.js theme={null}
import OpenAI from 'openai';
const client = new OpenAI({
baseURL: 'https://api.tess.im/agents/{id}/openai',
apiKey: 'YOUR_API_KEY',
});
async function main() {
const chatCompletion = await client.chat.completions.create({
messages: [{ role: 'user', content: 'Say this is a test' }],
model: 'gpt-4o',
});
}
main();
```
```python Python theme={null}
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.tess.im/agents/{id}/openai",
api_key="YOUR_API_KEY"
)
chat_completion = client.chat.completions.create(
messages=[
{
"role": "user",
"content": "Say this is a test",
}
],
model="gpt-4o",
)
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
| **Parameter** | **Type** | **Required** | **Description** |
| :------------ | :------- | :----------- | :-------------- |
| `id` | integer | Yes | The agent ID. |
### **Request Body**
See the [OpenAI API documentation](https://platform.openai.com/docs/api-reference/chat/create) for the full parameter reference. At the moment, our API only supports the `temperature` and `messages` (roles `system`, `user` and `assistant`) model parameters. Additionally, the `tools` parameter is a `string` enum. To verify the model parameters of a specific agent, see the [Get Agent](https://docs.tess.im/en/get-agent) endpoint.
### **Response**
See the [OpenAI API documentation](https://platform.openai.com/docs/api-reference/chat/object) for the response format.
# AI Step | Extract Text from Entire PDF
Source: https://docs.tess.im/en/pdf-extract
In this tutorial, we will explain how to use the "Extract Text from Entire PDF" Step on the Tess AI platform. This step is useful for extracting text from a PDF, allowing you to use it to train your model or consult the document.
Here are the details on how to fill in the fields and examples of use cases:
> \*\*Fields to Fill In: \*\*Enter the PDF file or link - In this field, you need to provide the link to a PDF file published on the internet and with public access enabled. Alternatively, you can use the result of the "Upload File" user input to extract data from files stored on your computer.
>
> \*\*Output Result: \*\*The text from the entire PDF will be extracted.
### **Use Cases:**
1. **Importing Contracts for Queries:** Imagine that you have a library of contracts in PDF format. Using the "Extract Text from Entire PDF" Step, you can extract the text from all these contracts and create a search model that allows users to search for specific terms in the contracts. This is useful for locating important information quickly.
2. **Importing Knowledge Bases for Queries:** If you have a knowledge base in PDF format, you can use this step to extract the content from all documents and make it available in a query system. Users can then search for and access relevant information effectively.
3. **Importing Documents for Training Across Different Industries:** If you are training an AI model for a specific industry, such as the financial, legal, or medical sector, you can use the "Extract Text from Entire PDF" Step to collect data from relevant PDF documents. This data can be used to train the model and improve its understanding of the industry, allowing it to provide more accurate and contextual information.
**Limitations:**
It is important to keep in mind that training your AI based on PDF documents extracted through Tess AI has a size limitation.
The training cannot exceed 80,000 words. Therefore, make sure that the selected PDF is within this limit. If you have a PDF with more than 80,000 words, consider splitting it into smaller parts or selecting only the most relevant sections.
Otherwise, it is better to use the GPTs mode in creation, adding the file as RAG.
The "Extract Text from Entire PDF" Step is a powerful tool that allows text extraction from PDFs for various purposes, from contract queries to training models in different industries. It simplifies the process of obtaining data from PDF documents and makes it easier to use this data in your workflow.
# AI Step | Read PDF Selected Pages
Source: https://docs.tess.im/en/pdf-pages
This function allows you to extract text from specific pages of a PDF document. It’s useful to focus on particular sections of a document without having to process the entire file, saving time and resources.
> **Fields to Fill In:**
>
> * Upload the file or PDF link: Provide a link to a publicly accessible PDF file. Alternatively, you can use the result of the "Upload File" user input to extract data from files stored on your computer.
> * Specify the Pages: Indicate which PDF pages you want to extract text from. You can enter a single page number, a range, or a comma-separated list.
>
> **Output Result:** The text from the specified pages will be extracted.
### **Use Cases:**
**1. Analysis of Specific Chapters:** Ideal for students and researchers who need to analyze specific chapters of academic books.
**2. Review of Legal Documents:** Allows lawyers to quickly review specific clauses in lengthy contracts.
**3. Compilation of Sector Information:** Makes it easier to collect information from certain sections of annual reports or technical documents for market analysis.
**Limitations:**
It’s important to keep in mind that training your AI based on PDF documents extracted through Tess AI has a size limitation.
Training cannot exceed 80,000 words. Therefore, make sure the selected PDF is within this limit. If you have a PDF with more than 80,000 words, consider splitting it into smaller parts or selecting only the most relevant sections.
### **Implementation Examples**
A user uploads a book PDF and specifies that only the pages from chapter 3 should be read to focus on a specific topic.
A lawyer uses a fixed link to a contract and extracts only the pages containing clauses of interest for quick review.
"Read PDF Selected Pages" is a valuable step in Tess AI to extract text from specific pages of PDF documents, enabling more targeted and efficient analysis of relevant information without needing to process entire documents.
# Rate Limits
Source: https://docs.tess.im/en/rate-limits
Rate limits act as control measures to regulate how frequently users and applications can access our API within specified timeframes. These limits help ensure service stability, fair access, and protection against misuse.
### **Understanding Rate Limits**
The default rate limit applied to all endpoints is **1 request per second**.
Rate limits apply at the organization level, not individual users. You can hit any limit type depending on which threshold you reach first.
### **Handling Rate Limits**
When you exceed rate limits, our API returns a `429 Too Many Requests` HTTP status code with a response like:
```
{
"error": "Rate limit exceeded",
"retry_after": 60
}
```
### **Best Practices for Handling Rate Limits**
1. **Implement exponential backoff**: When receiving a 429 response, wait the suggested time before retrying.
2. **Cache responses**: Store responses that don't change frequently to reduce API calls.
3. **Batch requests**: Combine multiple operations into a single request where possible.
4. **Monitor usage**: Keep track of your API usage to avoid hitting limits unexpectedly.
### **Rate Limit Increases**
If you need higher rate limits, please contact our support team with:
* Your use case
* Expected request volume
* Justification for increased limits
Our team will review your request and work with you to find an appropriate solution.
# Single and Multiple Selection
Source: https://docs.tess.im/en/select
We know that User Inputs are used to create flexible agents. However, instead of open text fields, you can present the user with a list of predefined options, ensuring that responses always stay within what’s expected.
In this tutorial, we’ll explore how to use the Single and Multiple Selection fields to create a smart travel planning agent.
### **Understanding Selection Input Types**
Ideal for when you need the user to choose only one option from a fixed list. This ensures the response is singular and decisive (e.g., "What’s your budget? High, Medium, or Low").
Perfect for allowing the user to select multiple options from a list. It offers more flexibility, multiple preferences (e.g., "What are your interests? Food, Culture, Sports").
For both types, the list options are created the same way: just type them into the configuration field, separated by commas.
### **Our Example Project: The Travel Planner Agent**
Let’s build an agent that works like a tour guide, creating a travel itinerary based on the user’s preferences.
In AI Studio, start creating a new agent. Since our agent will generate a text itinerary, a Chat or Text Agent is ideal. Keep the default "All LLM" selection or choose a specific model you prefer.
In the prompt field, we’ll insert the logic for our tour guide, the context, and the baseline guidelines that will guide it:
> *Assume the persona of an experienced tour guide and provide the best ways to explore the city according to the type of trip and the activities chosen by your client. At the end, add a note saying how important it is to check local hours and rules before the trip.*
>
> \_City: \
> Trip Type: \
> Desired Activities: \_
>
> *Critical: Create a highlighted theme for each chosen activity and offer more than one activity option. Do not mention the pandemic. Deliver only what was requested in the best way possible.*
The variables for city, trip type, and activities will be the connection points with our User Inputs.
Now, let’s create the interface our end user will fill out.
* Input for City: "Short Text", with the name city and the label "Which City and State do you want to visit?"
* Input for Trip Type (Single Selection): "Single Selection" with the name trip type and the label "What is your trip style?". For the options, enter the list of choices separated by commas. E.g.: Budget, Romantic, Adventure, Family, Luxury
* Input for Activities (Multiple Selection): "Multiple Selection" with the name activities and the label: "Which activities do you like the most?". For the options, enter the list of interests separated by commas. E.g.: Culture and Museums, Food, Nightlife, Shopping, Parks and Nature
Tip: Use the "+" button in the prompt editor to insert the variables into the prompt and ensure an exact match by referencing the variable in training.
With everything configured, name your agent and click "Save" and then "Preview" to test it. You’ll see a friendly interface with a text field, a dropdown menu, and checkboxes, ready to be filled out.
This tutorial shows how selection inputs can make your agents more structured, guiding the user and ensuring you receive information the way you expect. Keep exploring and creating your agents!
# AI Step | Google Sheets - Get Value
Source: https://docs.tess.im/en/sheets-read
This function allows you to extract data and information from Google Sheets spreadsheets by simply specifying the spreadsheet URL and the desired cell range. With the extracted data, you can train an AI model capable of interpreting and analyzing the information. This capability turns raw data into actionable insights, providing results that support decision-making in various business contexts.
> **Fill-in Fields:**
>
> * Enter the Spreadsheet URL: Provide the URL of the Google Sheets file you want to access. Another option is to preconfigure a fixed URL in the advanced step.
> * Specify the Data Range: Indicate the sheet name and the cell range you want to extract, for example, "dados\_abril!A1:C10".
>
> **Output Result:** The extracted data will be presented in a structured format, such as a file link or string, depending on the configured output format. The output type Link is recommended for cases where you’ll use subsequent steps that analyze files, and for transferring large volumes of data.
### **Use Cases**
Use this step to extract employee performance data directly from Google Sheets spreadsheets and, with this data, train an AI model to run analyses and identify potential leaders, training needs, or turnover risks. This approach enables more proactive, data-driven talent management, contributing to the development of a more engaged and productive workforce.
Extract financial data from multiple spreadsheets to perform automatic consolidations and variance analyses against the budget. With this data, you can apply an AI model to detect anomalies, forecast future cash flows, and optimize resource allocation, making strategic financial decision-making easier and improving the preparation of more accurate fiscal reports.
Configure the extraction of customer satisfaction survey data stored in Google Sheets and use AI to perform sentiment and text analysis. This helps you better understand customer perceptions, identify areas for improvement, and adjust products or services according to market expectations.
**Limitations:**
* The volume of extracted data depends on the correct specification of the cell range and is adapted to the LLM’s context.
### Output format
* Output format Text: returns a list of objects, using the first row as column names. Default: returns a list of rows similar to a matrix.
* Output format downloadable: returns the data as a string. Link: returns the data as a JSON-type Link for download.
The "Google Sheets Get Values" function is a powerful tool that transforms how companies analyze spreadsheet data. By extracting this information, you can train an AI model to perform deeper analyses and generate insights, turning simple datasets into valuable strategic information.
# AI Step | Google Sheets - Write Value
Source: https://docs.tess.im/en/sheets-write
This function allows you to add data and information to Google Sheets spreadsheets in an intelligent and adaptive way.
Users can specify the spreadsheet URL, the data range, and choose between overwriting existing data or adding it as a new row/column. You can use AI models to provide analysis and insights and have all the results integrated into Google Sheets, enabling easy data integration and updates, making the process more efficient and less error-prone.
### **Defining the Fields to Configure the Agent**
The first thing to do is select your spreadsheet for data analysis and processing.
As a first step, inside Agent Studio, we'll create an advanced "App Integration" step with the reference spreadsheet URL and the data reading range. As shown in the screenshot, we'll name the step Reader and select "Get Values", since we want to retrieve the data.
Another option is to not set a fixed URL in the advanced step. To do that, simply select the "Decisão do Usuário" option, and in that case, the recommendation would be to add a data input field and a reading range field as well, as shown in the screenshot.
Leading to the selection shown below:
Before modifying the spreadsheet, **we need to process and analyze what comes from the spreadsheet and the selected data range** — meaning we need to use an assistant that will evaluate and recommend the actions you as a user want, right?
> Here's an example of a survey where we want to analyze customer comments and summarize each comment in one word, as in the example below
| Comment | Summary |
| :------------------------------------------------- | :-------- |
| I didn't like it, I found it very difficult to use | Difficult |
| Excellent technology | Excellent |
| The onboarding steps are very complex | Complex |
Based on the example above, we'll select the AI Assistant Step and choose the Chat GPT Text Assistant, as shown in the screenshot below.
Note that inside the assistant, we already have a ready-made prompt with what we want to execute — meaning I'm already directing the ChatGPT assistant on what I want it to do.
> Below you'll find a table, each cell containing a message. I need you to create a new table, without markdown, bringing one word that summarizes each message. That is, each new row will have one word. \
> \
> Please bring only the table, without markdown, and nothing else. Respect the formatting: \[\["Col1", "Col2"], \["Data1", "Data2"]]\
> \
> \#messages\
> \*\*leitor\*\*
Of course, **I need to reference the spreadsheet I added**. That's why I highlight the reference to **Leitor**, the first step I added which holds the spreadsheet and its data range, **and I'll also bring exactly the data format I want the spreadsheet to return.**
In summary, what have we done so far?
1. We added the analysis spreadsheet (Creating the **Reader** using the App Integration Step and selecting Get Values, to retrieve the values)
2. We chose the data range for analysis (Creating the **Reader** using the App Integration Step)
3. We decided we want to process the data (Creating the **Processing** Step using the AI Assistant)
4. We decided how the processing will be done through a prompt that references the analysis spreadsheet (Defining the **Processing** Step using the AI Assistant)
So far so good!
What's left then? We already have the reading and the processing… we just need to write to the spreadsheet, right?
Now comes the easiest part. We've already read and processed the data — we just need to write it.
So let's create a new advanced "App Integration" step with the reference spreadsheet URL and the data range. But unlike field 1, we'll name this step Writer and select "Write Values", since we want to write the data, not retrieve it!
In addition, I need to make a few more selections:
* **Write range**: I need to select which column or space the processed data will be written to. Since in the reading I have the data in column "E" and those are the ones I'll process, I'll write to column "F", right next to it;
* **Data insertion method:** I can choose between overwriting the data in the selected range (as shown in the screenshot above) or creating new rows to avoid overwriting.
* **Include headers or not:** I can also choose whether or not headers should be taken into account.
* **Data values to be inserted:** as a final decision, I need to select what will be inserted in column F (my selection). Of course, I want the processed data to be that. And since I already have this Step ready — it was exactly my processing step — I just reference it.
Everything can also be a user decision, ok? In this case, since we're working based on the spreadsheet, we set everything up in advance, but feel free to customize it!
### **Finalizing the Agent**
To finalize the Agent, I just need to finish it with a desired prompt. In this case, since I already have everything I need, I'll set it up as a text Agent without the need for applied AI, simply returning the comments summarized in one word.
***After all, everything is already ready in the AI Steps***
### **Results**
Simply put, here is the result after requesting a generation.
**Before**
**Using the model**
**After use**
# Static Training
Source: https://docs.tess.im/en/static-training
In Tess, you can create multiple AI Agents. The secret to a truly effective agent aligned with your goals lies in Static Instructions, also known as the system prompt (System Prompt).
### **What are Static Instructions?**
Think of them as the "brain" or DNA of your Generative AI Agent. They are a set of guidelines, rules, and context that you provide to define how the AI will behave, what it needs to do, and how it should deliver the result to you. The persona, the objective, the task to be performed, the boundary conditions, the output format, etc. They are the foundation on which the agent will operate in all interactions, ensuring consistency and accuracy.
Unlike the questions you ask in a conversation (which are dynamic), static instructions are fixed and serve as the agent’s main source of truth.
### **Building the Perfect Prompt: The Anatomy of the Instruction**
Investing time in creating a good prompt is essential to your agent’s success. Creating an effective prompt is simpler than it seems. The key is to be clear, structured, and objective. To get the best results, follow the structure we call the "Ideal Prompt Anatomy II":
Start by giving the agent an identity. Is it a marketing specialist? A financial consultant? Describe their role, seniority level, and tone of voice. Giving it a name also helps consolidate the persona.
* Example (Formal): "You are the 'Pro Analyst', a senior technical support specialist at TechSolutions with 20 years of experience. Your communication must be formal, clear, and objective, always addressing the user as 'sir/ma’am'."
* Example (Creative): "You are the 'Idea Master', a brainstorming specialist for marketing campaigns. Your tone is inspiring and creative, but always focused on generating innovative concepts for the team."
What is the main task this agent should perform? Be specific about its functions and what it should do.
* Example: "Your main objective is to analyze sales spreadsheets to identify the five best-selling products of the last quarter. Your actions are: request the file, confirm receipt, analyze the data, and present the results."
Does the agent need information about your company, products, or policies to work? Include all relevant knowledge for the task here.
* Example: "You work for 'Solaria', a company that sells solar energy solutions. Our main products are the 'SunPower-X' panels and the 'Volt-Master' inverter. Our warranty policy is 5 years for all components."
* Example 2: "The reports you produce will always be reviewed by experienced investors, so the format must be executive, in a professional and sober tone."
Describe how the agent should structure its deliveries. Using clear examples here is essential to guide the AI.
* Example: "Present your analysis in a numbered list, from best-selling to least-selling. Always start with a two-sentence executive summary before presenting the list."
Provide the necessary warnings (positive or negative) for the agent—what it should always do or avoid. Do it clearly. As important as saying what to do is defining what the agent must avoid. This helps maintain focus, safety, and alignment.
* Example: "You must not, under any circumstances, provide personal opinions or create information that was not provided. If you don’t know the answer, state that you will consult a human specialist. Never offer discounts on the products."
Tips:
* Be Direct: Use clear language and avoid ambiguities.
* Use First Person: Write the instructions as if you were speaking directly to the agent (e.g., "You are...", "Your task is...").
* Test and Refine: Create a first version, test with different questions, and adjust the instructions and knowledge base as needed to improve the agent’s behavior.
By following these guidelines, you’ll be ready to create AI Agents in Tess that are not only intelligent, but also perfectly aligned with your vision and needs.
# Execute Agent Stream
Source: https://docs.tess.im/en/stream-agent
api-reference/agents-stream.openapi.json POST /agents/{id}/execute
Execute a specific **chat** agent by ID.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{id}/execute' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"stream": true,
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "hello there!" }
],
"tools": "no-tools",
"file_ids": [123, 321]
}'
```
```json Node.js theme={null}
const axios = require('axios');
const { parse } = require('eventsource-parser');
const data = {
"stream": true,
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "hello there!" }
],
"tools": "no-tools",
"file_ids": [123, 321]
};
const config = {
method: 'post',
url: 'https://api.tess.im/agents/{id}/openai/chat/completions',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
responseType: 'stream' // Required for handling streaming responses
};
async function fetchSSE() {
try {
const response = await axios(config);
response.data.on('data', (chunk) => {
const dataString = chunk.toString();
parseSSE(dataString);
});
response.data.on('end', () => {
console.log("\nStream ended.");
});
} catch (error) {
console.error("Error fetching SSE data:", error);
}
}
function parseSSE(data) {
// Use the eventsource-parser library
parse(data, (event) => {
if (event.data !== "[DONE]") {
try {
const parsed = JSON.parse(event.data);
console.log(parsed); // Process/Display received data
} catch (error) {
console.error("Error parsing SSE data:", error);
}
}
});
}
fetchSSE();
```
```python Python theme={null}
import requests
import sseclient
url = "https://api.tess.im/agents/{id}/execute"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
data = {
"stream": True,
"temperature": "1",
"model": "tess-5",
"messages": [
{"role": "user", "content": "hello there!"}
],
"tools": "no-tools",
"file_ids": [123, 321]
}
# Send the request with streaming enabled
response = requests.post(url, headers=headers, json=data, stream=True)
# Handle Server-Sent Events using sseclient
client = sseclient.SSEClient(response)
# Print each event as it arrives
for event in client.events():
print(event.data) # Print the data chunk received in the event
```
```php PHP theme={null}
true,
"temperature" => "1",
"model" => "tess-5",
"messages" => [
["role" => "user", "content" => "hello there!"]
],
"tools" => "no-tools",
"file_ids" => [123, 321]
];
$client = new Client();
try {
$response = $client->post('https://api.tess.im/agents/{id}/execute', [
'headers' => [
'Authorization' => 'Bearer YOUR_API_KEY',
'Content-Type' => 'application/json'
],
'json' => $data,
'stream' => true, // Enable streaming
]);
// Check that the response is successful
if ($response->getStatusCode() === 200) {
// Get the body as a stream
$body = $response->getBody();
// Iterate through each line of the stream
$parser = new \React\Stream\LineStream($body);
$parser->on('data', function ($line) {
// Check if this line is an SSE event
if (strpos(trim($line), 'data:') === 0) {
// Extract event data
$eventData = trim(substr($line, 5)); // Remove "data: " prefix
// Process or print the event data
echo "Received event: " . $eventData . PHP_EOL;
}
});
// Handle stream end or error
$parser->on('error', function ($error) {
echo "Error encountered: " . $error . PHP_EOL;
});
$body->on('close', function () {
echo "Stream closed." . PHP_EOL;
});
} else {
echo "Request failed with status: " . $response->getStatusCode();
}
} catch (RequestException $e) {
echo "Request failed: " . $e->getMessage();
}
```
```java Java theme={null}
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
Map data = Map.of(
"stream", true,
"temperature", "1",
"model", "tess-5",
"messages", List.of(Map.of("role", "user", "content", "hello there!")),
"tools", "no-tools",
"file_ids", List.of(123, 321)
);
String jsonPayload = mapper.writeValueAsString(data);
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{id}/execute"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofInputStream());
try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
String line;
while ((line = reader.readLine()) != null) {
if (!line.trim().isEmpty() && line.startsWith("data: ")) {
String jsonData = line.substring("data: ".length()).trim();
JsonNode event = mapper.readTree(jsonData);
// Handle the event (for example, print it)
System.out.println("Received event: " + event);
}
}
}
}
}
```
```go Go theme={null}
package main
import (
"bufio"
"encoding/json"
"fmt"
"net/http"
"strings"
)
// Event struct to parse the SSE data
type Event struct {
ID string `json:"id,omitempty"`
Event string `json:"event,omitempty"`
Data string `json:"data,omitempty"`
}
func main() {
payload := `{
"stream": true,
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "hello there!" }
],
"tools": "no-tools",
"file_ids": [123, 321]
}`
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/agents/{id}/execute", strings.NewReader(payload))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error making request:", err)
return
}
defer resp.Body.Close()
// Create a scanner to read the response body as a stream
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
line := scanner.Text()
if strings.HasPrefix(line, "data: ") {
data := strings.TrimPrefix(line, "data: ")
var event Event
if err := json.Unmarshal([]byte(data), &event); err != nil {
fmt.Println("Error parsing event:", err)
continue
}
// Handle the parsed event
fmt.Printf("Received event: %+v\n", event)
}
}
if err := scanner.Err(); err != nil {
fmt.Println("Error reading response:", err)
}
}
```
```jsonnet .NET theme={null}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.IO;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = new
{
stream = true,
temperature = "1",
model = "tess-5",
messages = new List
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
| **Parameter** | **Type** | **Required** | **Description** |
| :------------ | :------- | :----------- | :-------------- |
| `id` | integer | Yes | The agent ID. |
### **Request Body**
| **Parameter** | **Type** | **Required** | **Description** |
| :---------------------- | :------- | :--------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `stream` | boolean | Yes | Must be `true` for this streaming endpoint. |
| `temperature` | string | No | Chat Agent field. Sampling temperature between 0 and 2. Higher values produce more creative outputs (default: `"1"`). |
| `model` | string | No | Chat Agent field. Model identifier to use for execution (e.g., `"tess-6"`). |
| `tools` | string | No | Chat Agent field. Tool configuration for the agent (e.g., `"agent"`, `"no-tools"`). |
| `root_id` | integer | No | Chat Agent field. ID of an existing execution to continue a conversation thread. |
| `messages` | array | No | Chat Agent field. The agent messages. Required for Chat Agent templates. Supports `user`, `assistant`, `developer` roles. |
| `file_ids` | array | No | Array of file IDs to attach to the execution. |
| Other root-level fields | any | Depends on agent | This is not a fixed field name. You can send additional fields required by your specific agent directly at the request root. Check which fields are required in [Get Agent by ID](https://docs.tess.im/en/get-agent). |
### **Response**
```json wrap theme={null}
data: {"id": 123, "status": "running", "output": "Hi!", "error": null, "credits": null, "root_id": 123, "created_at": "2025-01-01T10:00:00.000000Z", "updated_at": "2025-01-01T10:00:00.000000Z", "template_id": 10}
data: {"id": 123, "status": "completed", "output": "", "error": null, "credits": 10, "root_id": 123, "created_at": "2025-01-01T10:00:00.000000Z", "updated_at": "2025-01-01T10:00:00.000000Z", "template_id": 10}
```
# AI Step | Extract Text from Docx
Source: https://docs.tess.im/en/text-from-docx
The Extract Text from DOCX step isolates and extracts textual content from Microsoft Word (.docx) files, delivering a clean block of text ready to be processed by AI agents. With it, complex documents become accessible data without the need for specific software or manual intervention.
### What is it
This step belongs to the Document Processing group — a category dedicated to transforming file formats into content usable by AI.
In practice, Extract Text from DOCX:
* Reads the internal structure of the .docx file
* Extracts text from paragraphs, tables, lists, headers, and footers
* Discards visual elements (images, charts, formatting)
* Delivers a block of plain text in the agent’s context
### Where to find it
1. Go to AI Studio
2. Click on Add AI Step
3. In Select Step Category, choose Document Processing
4. Select Extract Text from DOCX
### How to use?
Configuration fields:
| Field | Required | Description |
| :-------- | :------- | :----------------------------------------------------------------------------------------------------------- |
| Step Name | Yes | Internal step name. Use only alphanumeric characters. Used to reference the result in other steps or prompts |
| File URL | Yes | Direct public URL of the .docx file or a user file input variable (e.g.: `{{docxfile}}`) |
### About the Output
The generated result is a continuous block of plain text containing all content extracted from the document.
* Paragraphs
* List items
* Table data (linearized)
* Headers and footers
* Images and photos
* Charts and elements
* Visual formatting (colors, bold, italics, fonts)
Important:
Tables are read in a linear format, following the order of the cells. A well-structured prompt helps the agent correctly interpret tabular data extracted this way.
### Deeper explanation
The step works as a document decoding layer.
.docx file (URL or variable) → Step extracts plain text
↓
Content enters the context → Agent uses it to analyze, summarize, or extract data
The output should be treated as raw data injected into the prompt. The quality of the analysis depends directly on:
* Organization of the original document
* Clarity of the prompt that uses the result
***
### Practical examples
Prompt:\
"Analyze the extracted contract. Identify risk clauses, summarize payment terms, and extract client data."
Usage:
* Legal contracts or commercial proposals in .docx
* Agent identifies critical points without manual reading
Prompt:\
"Extract the candidate's skills, experience, and education. Compare with the job requirements below and evaluate the fit."
Usage:
* CVs submitted in .docx
* Agent classifies and summarizes profiles automatically
Prompt:\
"Summarize the main points of this report in up to 5 executive bullet points."
Usage:
* Monthly reports, meeting notes, or management documents
Prompt:\
"Extract from the document: company name, tax ID, total value, delivery deadline, and technical lead."
Usage:
* Standardized documents with fixed fields
* Feed CRM or spreadsheets automatically
**Best practices**
* Prefer well-structured documents: clear headings, paragraphs, and organized tables improve extraction accuracy
* Reference the step in the prompt: use the Step Name to indicate where the data comes from. Example: *"Based on the data from step *`extracao_contrato`*..."*
* Guide the agent about tables: mention in the prompt that tables may appear linearized so the model interprets them correctly
* Combine with other steps: e.g., Extract Text → analysis → Google Drive (save result)
* Avoid very long documents: files with many pages may exceed the agent’s context window
### Important notes
* The step runs before user interaction
* The file URL must be public and accessible
* Visual elements are completely ignored during extraction
* The output is raw text, without visual formatting
Extract Text from DOCX removes the barrier between Word documents and artificial intelligence. With it, contracts, resumes, reports, and manuals become processable data in seconds, enabling analysis, summarization, and automated extraction without any manual intervention.
# AI Step | Extract Text from TXT, XML, RSS, JSON
Source: https://docs.tess.im/en/text-from-txt-xml-rss-json
The Extract Text from TXT, XML, RSS, and JSON step converts structured or raw files into plain text, removing technical elements such as tags, keys, and syntax. With this, Tess transforms complex data into readable content ready for analysis by AI agents.
### What is the Step?
This step is part of the Document Processing category, responsible for cleaning and simplifying data from different formats.
In practice, it:
* Reads TXT, XML, RSS, and JSON files
* Removes:
* XML tags
* JSON structures (keys, arrays)
* RSS metadata
* Keeps only the relevant semantic content
* Delivers a clean block of text in the agent's context
### Where to find it
1. Go to AI Studio
2. Click on Add AI Step
3. Select Document Processing
4. Choose Extract Text from TXT, XML, RSS, and JSON
***
## How to use?
### Configuration fields
| Field | Required | Description |
| :-------- | :------- | :----------------------------------------------------------------------------------------- |
| Step Name | Yes | Internal step name (alphanumeric characters only). Used to reference the output in prompts |
| File URL | Yes | Direct URL of the file (TXT, XML, RSS, or JSON) or input variable (e.g.: `{{json}}`) |
## About the Output
The result is a continuous block of plain text, without any original technical structure.
* Semantic content (names, descriptions, values)
* All text relevant for human reading
* XML tags (``)
* JSON structures (`{}`, `[]`)
* RSS metadata
* Technical syntax
Important:
The original structure (hierarchy, nesting) is lost — the content becomes linear.
## Deeper explanation
This step acts as a normalizer of technical data into natural language.
File (TXT / XML / RSS / JSON) → Step removes technical structure
↓
Clean text is generated → Agent interprets semantically
Note:
* The AI focuses on the content, not the structure
* Ideal for inputs that were not originally designed for human reading
## Practical examples
Prompt:\
"Summarize the main news of the day and identify relevant market trends."
Usage:
* RSS feed from news portals
* Agent generates automatic curation
Prompt:\
"Analyze the logs and identify the main contact reasons and customer sentiment."
Usage:
* Chat or support logs
* Automatic issue classification
Prompt:\
"Based on the extracted data, generate a personalized prospecting email for each lead."
Usage:
* JSON export from CRM
* AI transforms into a commercial action
Prompt:\
"Organize the extracted information and highlight the main indicators."
Usage:
* API responses
* Transform technical data into insights
Best practices
* Use direct file URLs: avoid links that open web pages (HTML)
* Combine with structured prompts: e.g., "extract name, role, and company"
* Be careful with structure loss: nested JSON may lose logical context
* Use the Step Name in the prompt: e.g., *"Based on the data from step *`dados_crm`*..."*
* Combine with other steps: Extract → analysis → save to Sheets/Drive
## Important notes
* The URL must be public and direct (no login required)
* Original hierarchical structure is lost
* The step does not preserve data formatting or organization
* Large files may impact the context window
Extract Text from TXT, XML, RSS, and JSON is the bridge between technical data and artificial intelligence. It enables transforming APIs, feeds, and structured files into usable information, unlocking analysis, automations, and content generation based on data that previously required manual processing.
# Short and Long Text
Source: https://docs.tess.im/en/text-input
We know that User Inputs are the key to creating flexible agents, as well as being easy to use. In this tutorial, we’ll take a practical step and build an agent from scratch, exploring the two types of text input.
### **Understanding the Types of Text Input**
In AI Studio, when configuring a User Input of type "Text", you’ll have two main options:
Ideal for when you need the user to provide short and objective information, such as a name, a number, a keyword, a URL, or a title.
Perfect for situations where the user needs to provide a larger volume of information, such as a paragraph of instructions, a block of text to be analyzed, or a detailed description.
### **Our Example Project: The Scriptwriter Agent**
Let’s create an example agent capable of developing a script for voiceover on a central theme, with a specific duration.
Remember that creating an agent goes through the stages of idea design, development, testing and refining the prompt, up to its effective creation.
In AI Studio, create a new agent. For this example, a Chat or Text Agent is ideal. Keeping the default selection of "All LLM" will also work perfectly, and I’ll allow the end user to choose:
We’ll use a more concise prompt that will work for now and will fill the prompt field:
> *Assume the persona of a senior scriptwriter and storyteller, specializing in creating engaging narratives for documentary and institutional videos. Your mission is to develop an original and impactful script for a professional voiceover, addressing the following theme: \[The variable will go here]*
>
> *The script must be structured with an introduction that sparks curiosity, a development that explains the topic clearly and smoothly, and a memorable conclusion. Use language that is both elegant and accessible, focusing on creating strong mental images for the listener.*
>
> *The final result must be only the text to be narrated, pure and clean, without any kind of special formatting, character names (such as 'Narrator:'), titles, or scene directions. Deliver a text that is ready to be recorded.*
Now we’ll create the field that the end user will fill with the theme. Since we’ll use only one variable, we’ll need just one field.
* Click "Add User Input" and select short text
* In the "Variable Name" field, type exactly tema.
* In the "Label" field (what the user will see), type something friendly, such as "What is the script theme?".
Remember the Essential Connection: The agent’s success depends on the exact match between the Variable Name (tema) and where it will appear in the prompt. That’s how the AI knows where to insert the user’s information.
With the prompt and the single input configured, name your agent, click "Save", and then "Preview".
This simplified agent demonstrates the essence of User Inputs: creating a reusable and easy-to-use tool.
The beauty of AI Studio is that you can start with an agent like this—simple and functional—and then, if necessary, add more complexity. You could, for example, create a new version of this agent and add a second User Input for "Tone of Voice" (e.g., "Serious", "Relaxed", "Inspiring"), making your tool even more powerful.
Mastering the basics is the first step to building increasingly amazing agents. When you’re satisfied, you can change your agent’s visibility in AI Studio to publish it and make it available to other users in your workspace.
Keep exploring and combining different types of input to create increasingly sophisticated and useful AI tools.
# Transcription Generator
Source: https://docs.tess.im/en/transcription-gen
Turn audio or video recordings into text quickly and accurately with Tess AI.
### **How to Transcribe with the Generator?**
The process to transcribe an audio or video file in Tess AI is simple and intuitive. Transcription can be done in two ways: using the specialized agent (Transcription Generator) or directly in the chat, with control over language and AI model.
To use the Transcription Generator, follow the steps below:
Access Agent Studio: In the platform’s left side menu, find and click "Agent Studio". Click Transcription Generator;
You will find a “choose file” icon. Click it to select the audio or video file you want to transcribe from your computer.
Request the transcription using the “Tess, generate it for me” button. The AI agent will process the file and, in moments, deliver the full transcription directly on the screen, on the right side. From there, you can copy the text wherever you need.
### **Tips for a high-quality transcription**
To ensure the transcription is as faithful as possible to the original audio, consider the following best practices:
Prefer audio with clear sound, no background noise, and with speakers talking slowly and clearly.
The platform is compatible with the most common audio and video formats, such as MP3, MP4, WAV, and M4A.
Our agents are able to transcribe audio in multiple languages. For best results, make sure the audio’s language is spoken clearly.
### **Everyday use examples**
The transcription feature can be a great ally in many situations. See some examples:
* Meetings and interviews: Turn long meeting recordings into minutes or text documents for quick reference.
* Classes and lectures: Transcribe classes and lectures to make studying and reviewing content easier.
* Content creation: Use video transcriptions as a base for captions, blog articles, and other materials.
If you have any questions, our support team is always available to help at [support@tess.im](mailto:support@tess.im).
# File Upload
Source: https://docs.tess.im/en/upload
Take your agents to a new level of capability by allowing them to process files. The File Upload User Input is the gateway to creating agents that can read documents, transcribe audio, analyze videos, and much more.
This intermediate-level tutorial assumes you’re already familiar with basic agent creation and will focus on the powerful combination of file inputs with Advanced Steps.
### **The Key Point: The Connection Between File Upload + Advanced Step**
Unlike a text input, which can be used directly in the prompt (or in the step), "File Upload" needs to connect to an Advanced Step. The workflow is a logical two-step sequence:
* The user uploads a file (through the User Input).
* An Advanced Step (such as "Audio Transcription" or "PDF Text Extraction") processes that file and generates a result (text, for example).
* The result of the Advanced Step is then used by the AI in the main prompt to generate the final response.
**Our Example Project: The Media Translator Agent**
To illustrate this powerful combination, we’ll build an agent that works as a translator. It will be able to receive an audio or video file, transcribe the content, and translate it to Portuguese, or another language.
In AI Studio, start by creating a new Chat or Text Agent. The default "All LLM" selection is perfectly suitable for this example.
This is the most important stage. We’ll configure the two parts that will work together.
In "User Inputs", add a new "File Upload" input with the variable: arquivo original. For the label, use: "Send your audio or video file"
In "AI Steps", search for the AI-Audio Transcription step, select the desired AI Model, and name the step transcribed text.
In the file field, choose the *arquivo-original* variable to make it dynamic. With that, you created a flow where the user uploads the file and it is processed and transcribed by the step. Now it’s time to use the step result in the agent prompt!
Now, we’ll tell the AI what to do with the text extracted by the Advanced Step. In the prompt field, we have:
> *Assume the persona of a Tess AI expert in transcription and content localization. Your mission is to process the text extracted from a media file and deliver a clear, professional result in two parts.*
>
> *Part 1: Faithful Transcription*
>
> *Create a section titled "## Original Transcription".*\
> *In this section, present the exact text from the audio. The goal is maximum fidelity:*\
> *- Keep the original structure and punctuation.*\
> *- If a segment of the audio is unintelligible or uncertain, use the \[inaudible] tag in the corresponding spot.*\
> *- Do not add, omit, or correct words.*
>
> *Part 2: Natural Translation*
>
> *Below the transcription, create a second section titled "## Translation to Portuguese (BR)".*\
> *In this section, translate the text into Brazilian Portuguese. The focus here is naturalness and fluency:*\
> *- Avoid literal translations that sound robotic.*\
> *- Adapt the meaning and intent of the message to the target language, keeping the original tone (whether formal, casual, technical, etc.).*
>
> *The final result must contain only these two sections, clearly separated by the titles. Do not include any introduction, commentary, or additional conclusion.*
>
> *This will be done based on the following content: transcribed-text*
**IMPORTANT**\
\
Note that the prompt uses the variable that is the result of the Advanced Step, not the initial upload variable. This connection is what makes the entire flow work with files!
Click "Save" and then "Preview". You’ll see an interface with a file upload button. Upload a short audio or video (200mb file size limit) in another language and let the agent handle the rest!
Mastering the connection between a "File Upload" input and an Advanced Step is the key to building agents that interact with the world beyond text.
The translator example is just one of infinite possibilities. You can use the same principle to create agents that read PDFs, analyze reports, and much more, automating complex tasks intelligently.
# Video Generator
Source: https://docs.tess.im/en/video-gen
If an image is worth a thousand words, a video can tell an entire story. With Tess AI’s Video Generator, you create moving clips from a text description (prompt) or even from a reference image (depending on the model chosen).
It’s ideal for marketing, social media, product demos, educational content, and creative experimentation.
### **You can generate videos in three ways in Tess AI:**
For this path, in the left side menu we access Agent Studio and then the Video Generator.
This is the fastest way to turn an idea into a video without leaving the conversation.
If you need to maintain consistency (same style, format, and guidelines), create a specialized agent.
### **What the Video Generator is and how to use it**
In this article, we’ll focus on generating videos through the Generator, whose interface will act as your “production studio” inside Tess AI. It uses AI models capable of interpreting your instructions and creating moving scenes — usually as short clips, ready for you to download and use.
To work with video generation, pay attention to the prompt, the chosen model, and the settings available in each model.
Describe the scene (the prompt). Here, you should think in terms of movement and action (not just “what the image looks like”). So include elements such as:
* Subject: who or what appears
* Action: what is happening. Use verbs (movement is everything): "running", "spinning", "floating", "flying over", "cutting", "approaching", "the camera follows", "the camera moves closer", "the camera passes through"
* Environment: where the scene takes place
* Style: realistic, animation, cinematic, etc.
* Camera: angle and camera movement
Prompt examples (good)
1. "A golden retriever running in slow motion on a sunny beach at sunset, gentle waves in the background, cinematic style."
2. "Close-up of hands typing on a mechanical keyboard, blue and purple neon light, shifting focus, slight handheld camera, vlog style."
3. "Aerial tracking shot over a dense, foggy forest at dawn; sunbeams cut through the mist and reveal a winding river below."
**Tip:** You can improve your prompt with Magic Prompt; it enhances and translates your command to make it even better!
In addition, you can use the + Add to Scene feature to include visual and motion elements in your prompt.
You can choose the elements you want and, at the end, add them to the prompt:
After the prompt, it’s important to choose a video model that will be responsible for generating your animation, motion, or bringing your video to life. In Tess AI, we have a list of several available models. To find one, you can type its name or scroll down:
Each model has its own characteristics: some allow reference images, others don’t, and some work from videos. The best way to find out which works best for you is by experimenting or opening each model’s specifications on official release pages.
Depending on the selected model, you can adjust items such as:
* Video aspect ratio (e.g., 9:16 vertical for Reels/TikTok, 16:9 for YouTube)
* Duration (short clips)
* Style/quality (when options are available)
* Variations (generate more than one option)
### Done!
After you send the prompt, Tess processes it and returns the clip. The cost to generate each video, according to the chosen model, will appear next to the generation button:
**IMPORTANT!**
Since we trigger the model to generate your video, if there is any intermittency or error in the model provider’s API, the process may exceptionally fail. This is very rare, but possible. If your video is not generated, don’t worry—credits will be returned to your wallet within up to 1 hour.
Either way, it’s important to check if there was something in the process, on the user’s side, that may have caused the failure, such as:
* Prompt length: avoid prompts over 500 characters
* Reference image: check the format you sent and what the model supports
Tess AI’s Video Generator boosts dynamic content creation: you go from idea to a finished clip in minutes. Start simple, refine the prompt, and if the usage is recurring and within the same patterns, create a Video Agent to keep consistency and gain scale.
# Visibility
Source: https://docs.tess.im/en/visibility
Visibility defines the privacy level of the agent created in Agent Studio. You can choose between the following levels:
Available only to members of your workspace. This is the ideal mode to maintain control over internal agents.
Visible to the creator and, when the workspace policy allows, to profiles with **governance permissions** to audit private agents from other members — being a workspace member alone is not enough to view others' private agents.
Available for use by the entire Tess user community and listed in the Marketplace.
Does not appear in the Marketplace, but anyone on Tess who receives the link can access it.
### **Why is it important?**
* Security and confidentiality: agents with sensitive data should be private or limited to the workspace.
* Controlled sharing: experimental agents can be unlisted, accessible only via link.
* Distribution and community: mature agents can be made public and shared with the entire Tess base.
### Understanding Visibility Levels in detail
All workspace members can access the agent. It is great for creating agents within companies so that other colleagues can use them.
By default, only the creator can see the agent in the listing. To **audit or access** a private agent from **another member**, **explicit governance permission** in the workspace is required (simply being an Owner does not automatically grant access to others' private agents). Ideal for drafts, tests, or personal agents.
In this case, any Tess user can find and use the agent, making it available and listed in the Marketplace. These are used for agents ready for reuse by others (more generic and broad), market templates, showcases, etc.
They cannot be found in the Marketplace and only people with the direct link can open them. It is used when you want to share with specific clients, partners, or in beta phases for testing by others.
### **Governance and private content in the workspace**
The platform reinforces that **visibility** (public, workspace, private, unlisted) is not the only control: for **private agents and results of other members** within the same workspace, an explicit **governance** model applies:
* **Same rules across all flows:** AI Studio, chat, usage history, access to linked documents, and **template/execution APIs** apply the same authorization. There is no “shortcut” in the API that exposes another user’s private content without proper permission.
* **No role-based bypass:** having an Owner or administrator role **does not replace**, by itself, governance permission to **read or audit** private agents and **private sessions/results** from others — when the policy requires explicit permission, access is clearly denied.
* **Denial experience:** unauthorized attempts lead to a **private content** experience (access denied), instead of ambiguous messages that do not make it clear whether the resource exists.
* **Usage history:** items you cannot open due to lack of permission appear as **restricted**, without any link that simulates improper access.
Who can audit private content and under which conditions depends on the **workspace permissions** and the **governance features** of your plan (often in **Enterprise** scenarios). Also check [Members and Permissions](/pt/members-permissions).
### **How to adjust agent visibility**
When creating the Agent, you can define visibility within Agent Studio by selecting your preferred option. The agent will be created with that setting.
Additionally, you can always adjust the visibility level in Agent Studio:
1. Open Agent Studio
2. Locate the agent you want to configure. You can search by name, type, visibility, or owner.
3. Check the Visibility column and choose the desired level
**IMPORTANT**\
\
**When publishing an agent, it goes through a review before appearing to everyone**
When you set an agent as **Public** in AI Studio, TESS automatically reviews the content — text and images. If everything is in order, it is approved and becomes available to the community. The process is automatic and happens in seconds.
### **Detailed Agent Information (to make it public)**
To access it, just hover next to the status and click the pencil icon.
This will open the detailed agent settings:
### Required fields for public publishing
Before publishing an agent publicly, make sure these fields are filled. They will be highlighted on the Publishing Settings screen if missing.
1. **Short Description:** What the agent does, in one paragraph
2. **Long Description:** Detailed use cases and benefits
3. **Category:** Area of activity (e.g.: Marketing, HR, Sales)
4. **Cover image and avatar:** Recommended — improves presentation in the marketplace
**Rejected images are automatically removed** from the agent to prevent improper display.
### **How to resolve a rejection**
Hover over the red icon next to the visibility badge to see which area failed (text, avatar, or cover).
Open the agent settings and adjust the indicated field — replace the image or revise the text according to the tooltip guidance.
No additional action is required. When you save, the agent returns to *Under review* and the automatic analysis is re-executed.
### Required fields for public publishing
Before publishing an agent publicly, make sure these fields are filled. They will be highlighted on the Publishing Settings screen if missing.
1. **Short Description:** What the agent does, in one paragraph
2. **Long Description:** Detailed use cases and benefits
3. **Category:** Area of activity (e.g.: Marketing, HR, Sales)
4. **Cover image and avatar:** Recommended — improves presentation in the marketplace
**Rejected images are automatically removed** from the agent to prevent improper display.
### **How to resolve a rejection**
Hover over the red icon next to the visibility badge to see which area failed (text, avatar, or cover).
Open the agent settings and adjust the indicated field — replace the image or revise the text according to the tooltip guidance.
No additional action is required. When you save, the agent returns to *Under review* and the automatic analysis is re-executed.
**Best practices**
* Start with the agent as Private during the testing phase.
* When it is mature, switch to Workspace so the whole team can use it.
* Only make Public what you truly want to share with the community, without sensitive data.
* Use Unlisted for pilots with selected clients, without exposing it in the Marketplace.
# Voiceover Generator
Source: https://docs.tess.im/en/voiceover-gen
With Tess AI’s Audio Generator, you can convert any text into a smooth, natural voiceover using a wide range of voices and languages.
### **What is the Audio Generator?**
The Audio Generator is an Artificial Intelligence tool that synthesizes a human voice from written text. Integrated into Agent Studio, it allows you to generate high-quality audio files without the need for microphones, recording studios, or professional voice talent.
With an intuitive interface, you can choose between different voice profiles, adjust the tone, speed, and narration style so it fits perfectly with the message you want to deliver.
### **How to Use the Audio Generator?**
Generating a voiceover is a quick process. Follow the steps below:
After accessing the area, explore the configuration options in the menu to select the voice, language, and style you prefer.
Click the button to add new; it will generate an audio file only with what is written next.
After adjusting the settings, in the text field, type or paste the content you want to narrate.
Click the button to generate the audio. You can listen and, if you’re satisfied, download the file. Or switch the voice, improve the text, and generate a new one.
### **Practical Applications for Your Business**
The Audio Generator is a versatile tool that can be applied in different contexts. Here are a few examples:
Create voiceovers for your institutional, tutorial, or marketing videos.
Develop more accessible and dynamic courses and educational materials.
Produce your own podcast audio content or turn blog articles into audio versions.
Generate standardized audio messages for IVR (Interactive Voice Response) systems.
### **Tips for a High-Quality Voiceover**
To ensure the result sounds natural and professional, consider the following tips:
* Review the Text: Typos or grammar errors can be interpreted literally by the AI. Always review the text before generating the audio.
* Use Punctuation: Commas, periods, and other punctuation marks help the AI create the correct pauses and intonation, making the narration more human.
* Test Different Voices: Each voice has a unique style. Try different profiles to find the one that best aligns with your brand and your audience.
Remember that you can also create audio and voiceovers in Tess AI Chat by enabling the tools relevant to these functions. This can be useful when you’re already in a conversation and want to keep going on the same project within the chat.
Explore the power of the Audio Generator and discover how Tess AI can help you create audio content in an innovative way with professional quality.
# AI Step | Web Data Extraction
Source: https://docs.tess.im/en/web-extract
In Tess AI, your agents can go far beyond static knowledge. With Web Data Extraction Steps, you can turn them into intelligent researchers, capable of fetching up-to-date information directly from the internet.
This guide will show you how to configure your agents to find job openings, compare product prices, search for news, and much more — in a fully automated way.
### **What are Web Data Extraction Steps?**
Steps are building blocks that you add to your agent's logic in Agent Studio. The Web Data Extraction category groups a series of steps designed to perform searches across different online platforms.
Instead of a generic search, these steps allow you to create highly personalized and targeted searches, enhancing the agent's training with up-to-date and relevant information. The options include:
* Google Organic Search: For general searches, news, and information.
* Google Shopping Search: For searching products and comparing prices.
* Google Jobs Search: For finding job openings.
* Amazon Product Search: For searching products directly on Amazon.
* And many more.
### How to Configure an Agent with Web Search
1. Access Agent Studio and start creating or editing an agent.
2. Add a Step: On the creation screen, locate the "AI Steps" section and add a new step.
3. Select the Step Type: Choose the Web Data Extraction category and then the desired search type (e.g.: Google Shopping Search).
4. Configure the Search: Fill in the search-specific fields. For example, the name of the product you want to search for. At this stage, you can choose to pre-configure some of the requirements as defaults, or use the user definition to create inputs and leave that field variable.
> For example, if the domain always needs to be a specific country, you can configure it in advance. Or if the product must have a specific name, you can fill it in already. Otherwise, either activate the user decision or create inputs and reference them in the specific fields.
>
>
>
>
5. Define the Step Name: This is a crucial step. Give a name to the result of your search (e.g.: product search). This name will become the variable you will use in your prompt to access the collected data.
With that, the search step is ready. Now, the secret is to connect this step to a good prompt.
### **Practical Example: Deals Search Agent**
Let's create an agent that finds the best deals on Google Shopping.
* Step Type: Google Shopping Search
* Product Search: A variable can be used here
* Domain and Language: Based on your target market and language
* Step Name: product search
The Step retrieves the raw information. Your prompt is what transforms that information into a useful and intelligent response.
Suggested Prompt:
> Assume the persona of an expert in electronics deals analysis. Your task is to analyze the product search data, available at: **product-search**.
>
> Based on that data, do the following:
>
> 1. Identify the three best deals, considering the price and the store's reputation.\\
> 2. Present a clear summary of each deal in list format.\\
> 3. For each item on the list, include the product name, the price, the store name, and the direct link.\\
> 4. At the end, write a paragraph explaining why these three deals are the most advantageous at this time.
When running the agent, it will first perform the search on Google Shopping (the Step) and then use the collected data to execute your prompt's instructions.
Tips:
* The Prompt is the Brain: Be detailed in your instructions. The Step collects the data; the prompt analyzes it. The clearer the prompt, the better the analysis. Always remember to add the parameter created for the Step into your prompt.
* Be Specific in Your Search: The more specific your query in the Step (e.g.: "iPhone 15 128GB Black" instead of "iPhone"), the more relevant the results will be.
Integrating web data extraction Steps transforms your agents from static repositories into dynamic assistants.
By mastering the combination of search steps with detailed prompts, you can create powerful tools to automate market research, monitor news, and save valuable time.
# Workspace ID
Source: https://docs.tess.im/en/workspace-id
The **Workspace ID** is the unique identifier of your workspace on Tess. It is required in **every call to the Tess API**, including integrations made with N8n, Zapier, Make, Power Automate, HTML/JavaScript code, or any other tool that sends HTTP requests.
This identifier is sent in the `x-workspace-id` header and indicates which workspace the request is coming from. In practice, it defines **where the execution credits will be consumed from**.
The Workspace Id does not work as a filter, you can find any public agent in the API that is available on Tess and that is in other Workspaces.
### What is it?
Every Tess user is linked to one or more **workspaces**: spaces where agents, automations, members, and credits are organized.
The **Workspace ID** is the numeric code that uniquely identifies each of these environments.
Every time you make a call to the Tess API — whether directly through code or through an integration platform — send the Workspace ID in the `x-workspace-id` header.
Tess uses this value to identify:
* The workspace of origin of the request;
* The workspace associated with the API Key used;
* The workspace from which the execution credits will be deducted.
**Important:**
The `x-workspace-id` **does not limit which agents can be executed**. You can run public agents from other workspaces, as long as you have access to them. In that case, the call still originates from your workspace and the credits are consumed from it.
## Where to find it
To locate the Workspace ID of the current environment:
1. In Tess, open **Settings**.
2. Click on **Workspace**.
3. Locate the **Workspace ID** field.
4. Copy only the number shown.
This is the recommended method, as it avoids confusion when you have access to more than one workspace.
There is an alternative option, identifying it via URL, but attention is needed to avoid any errors:
* Look at the browser's address bar and locate the `w=` parameter. The number right after this parameter is the Workspace ID.
**Example:**
```text theme={null}
https://app.tess.im/... ?w=12345
```
When using the URL, confirm that you are browsing in the correct workspace before copying the value.
This value is always the value of the **workspace you are accessing**, regardless of whether the executed agent is yours or belongs to a third party. But if you have access to more than one, analyze from where the API request will originate and use it in the parameter.
## Applying it in the API
Include the Workspace ID in the `x-workspace-id` header in **every request sent to the Tess API**.
In addition to it, also include your API Key in the `Authorization` header.
```text theme={null}
Authorization: Bearer YOUR_API_KEY
x-workspace-id: 12345
```
## This applies to calls made from:
* Your own code, such as HTML, JavaScript, Python, or other languages;
* API testing tools, such as Postman or Insomnia;
* Automation platforms, such as **N8n, Zapier, Make**, and Power Automate;
* Internal systems, CRMs, backends, and custom integrations.
In integration platforms, manually configure these values in the **Headers** section of the HTTP request module or step.
Then, send the remaining call parameters, such as the `agent_id` and the `prompt` that will be processed by the agent.
## Best practices
* Include the `x-workspace-id` in every request to the Tess API.
* Prioritize checking **Settings > Workspace** to copy the correct ID.
* Copy only the Workspace ID number, without spaces or extra characters.
* Always use the Workspace ID associated with the API Key configured in the integration.
* In automations with multiple agents, keep the same `x-workspace-id` when the calls originate from the same workspace.
* Store the API Key in environment variables, credential vaults, or secure fields of the integration platform.
* Never share your API Key in prompts, messages, public repositories, or screenshots.
Important note
In any integration with the Tess API, send the x-workspace-id along with your API Key. This header identifies the workspace of origin of the call and ensures that credits are counted correctly — whether in your own code, in N8n, Zapier, Make, or another automation tool.
# Your Account
Source: https://docs.tess.im/en/account
Maintaining your personal data up to date is essential for security and proper identification on the Tess platform. The "Account" section within your settings is the central place to manage all your profile information.
This article shows how to access and modify your personal data.
### **How to access Account settings**
Log in to your Tess account and then click on your profile icon, located in the bottom-left corner of the screen. In the menu that opens, select the "Settings" option.
By default, you will be directed to the "Account" tab. On this screen, you can manage the following information:
1. Personal Data: Change your first name, last name, and profile picture.
2. Access Email and Location: Modify the email address associated with your account, as well as your location.
3. Password Change: Create a new password to access your account.
4. Delete Account: Start the process to permanently delete your Tess AI account.
**Important Warning About Account Deletion**
The action of deleting your account is permanent and irreversible. Once confirmed, all your data, agents, history, and settings will be lost. All your work will be discarded. Be absolutely sure before proceeding with this action.
# Addons
Source: https://docs.tess.im/en/addons
Addons are extra features that you can enable in your account to expand Tess’s capabilities. They work like “extensions” that enhance your chat experience — from smarter searches to expanded context windows. Enable only what you need and customize your platform according to your workflow.
### **What are Addons?**
Addons are optional modules available in your Tess account. Each addon enables a specific behavior that is not available in the platform’s default experience.
Unlike Tools (features activated during chat), Addons act in a more structural way — some impact how files are indexed, others how the model processes context, and others how you interact with agents and control the creativity of responses.
### Where to find
Access Addons through the settings menu after clicking on your user icon:
### What Addons are available
Enables a hybrid search index across all your files. It combines semantic search (by meaning) with lexical search (by keywords), making document information retrieval more precise.
Ideal for: Users who work with large volumes of files and need more accurate answers based on documents.
When enabled, all account files automatically use the hybrid index.
Allows you to mention other agents during a conversation using the @ symbol. This way, you can trigger the specialized capabilities of different agents without leaving the current chat context.
Ideal for: Workflows involving multiple agents with distinct roles (e.g., a research agent + a copywriting agent).
During chat, type @ followed by the name of the agent you want to trigger.
Extends the language model’s context window, allowing longer conversations and analysis of larger documents without losing information throughout the history.
Ideal for: Analyzing long contracts, lengthy reports, or conversations with many chained steps.
Larger context windows may impact credit consumption when Max Mode is enabled.
Allows you to control the model’s temperature — that is, the level of creativity and randomness in generated responses.
Low temperature: More precise, consistent, and objective responses.
High temperature: More creative, varied, and exploratory responses.
Ideal for: Advanced users who switch between analytical tasks (low temperature) and creative tasks such as copywriting or brainstorming (high temperature).
Addons are the most direct way to adapt Tess to your work style. With just a few clicks, you expand what the platform can do — whether it’s retrieving information more accurately, writing more creatively, or integrating multiple agents into a single conversation. Explore what’s available and keep an eye on what’s coming next.
# Affiliates
Source: https://docs.tess.im/en/affiliate
The Tess AI Affiliate Program is your opportunity to share our platform with your network and be rewarded for it. If you believe in the potential of Tess AI, this program was made for you to become one of our ambassadors.
### **How does the Affiliate Program work?**
The model is simple and beneficial for everyone. For every referral you make that converts into a new customer, everyone wins.
\
The person who subscribes to Tess AI using your exclusive affiliate link gets a 10% discount at the time of purchase, applied to the plan they choose.
\
You receive a 10% commission on the amount your referral pays during the first 12 months of their subscription.
### **Important Commission Details**
\
The 10% commission is recurring on payments made by the customer during the first 12 months of the contract.
\
There is currently a total commission cap of up to \$1,000 (one thousand dollars) per customer you refer.
### **Practical Example of Earning Potential**
Imagine you referred Tess AI to a company, and they purchased a plan with 10 licenses (seats) at a cost of \$40 per license/month.
> *Annual contract value: 10 seats x \$40 x 12 months = \$4,800*
>
> *Your commission (10%): \$480*
>
> With a single referral, you would earn \$480.
### **How to Join: Step-by-Step Guide**
To generate your link and start referring, the process is very quick:
Make sure you’re logged into the account you want to generate the link from.
Click the "Share Tess with a Friend” button (in the side menu) or, after clicking your user icon, look for the "Earn up to \$1000" option.
On the program page, click the button to copy your exclusive invitation link.
Share your link! You can send it directly to your contacts or use the quick share buttons for social networks like LinkedIn, WhatsApp, and email.
### **Tracking Your Results and Payments**
You have full transparency to track the performance of your referrals.
Within the same affiliate program page, click the "Rewards" tab or your dashboard. There, you’ll be able to see the status of your referrals and your accumulated earnings.
It’s important to note that a new sale can take, on average, 20 days to appear in your dashboard. This period is necessary to complete all financial and confirmation steps.
Payments are made via PayPal. To receive them, just add your PayPal account in the program’s payment settings area. If you don’t have an account yet, you can create one for free on the PayPal website.
**Troubleshooting: Payment with "Returned" status**
Occasionally, a commission payment may not be completed and may appear with the status **"Returned."**
This means the payment was correctly processed by our payments partner (Cello), but it was returned by PayPal due to an issue with the affiliate’s own account.
The most common reasons for this to happen are:
* The PayPal account email registered on the affiliate platform is incorrect or doesn’t exist.
* The PayPal account hasn’t been fully verified.
* There is a restriction or block on the PayPal account that prevents receiving funds.
> **How to fix it**
>
> * Review your details: Make sure the PayPal email registered in the affiliate dashboard is correct.
> * Check your PayPal account: Log in to your PayPal account and confirm there are no pending verification steps or account restrictions. If you have questions, contact PayPal support.
> * Update the information: After fixing any pending issue, update or re-enter your payment email in the affiliate dashboard. A new payment attempt will be made automatically in the next cycle.
If you prefer, you can also contact our payments partner’s support directly by email: [support@cello.so](mailto:support@cello.so).
Or, if you have any questions about the Affiliate Program, our team is available to help by email: [support@tess.im](mailto:support@tess.im).
# MCP Server
Source: https://docs.tess.im/en/api-mcp
Connect Tess AI to Claude, Cursor, Codex, and any MCP-compatible platform — securely, with your own API token.
The **Tess AI MCP Server** turns your Tess agents, executions, and memories into tools that any **Model Context Protocol (MCP)** client can call. It is a **hosted, managed endpoint**: there is nothing to install, package, or run.
Point your AI platform at a single URL, authenticate with your **Tess API token**, and your team can list, run, and orchestrate Tess agents directly from the tools they already use.
**Endpoint:** `https://mcp.tess.im` — a remote MCP server using the **Streamable HTTP** transport. No `npx`, no local process, no Node.js required.
## Why connect through MCP
Run Tess agents from inside Claude, Cursor, Codex, or your own internal tools — no context switching, no copy-paste.
A managed endpoint maintained by Tess. New capabilities appear automatically; there is no client to upgrade.
Every call runs with the caller's own API token and workspace, inheriting your existing roles, permissions, and credit limits.
Built on the open Model Context Protocol. The same endpoint works across every MCP-compatible platform — no per-vendor integration.
## What the server exposes
The tool surface is **generated automatically from the Tess API** — every endpoint becomes an MCP tool, so new API capabilities show up without any change to the server. Every tool is listed below, grouped by domain, each with its own linkable entry in [Tools reference](#tools-reference).
| Domain | Tools |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agents** | [`list_agents`](#list-agents) · [`get_agent`](#get-agent) · [`execute_agent`](#execute-agent) · [`list_files_agent`](#list-files-agent) · [`link_files_agent`](#link-files-agent) · [`delete_file_link_agent`](#delete-file-link-agent) · [`list_agent_responses`](#list-agent-responses) · [`get_agent_response`](#get-agent-response) · [`list_agent_webhooks`](#list-agent-webhooks) · [`create_agent_webhook`](#create-agent-webhook) · [`agent_chat_completions`](#agent-chat-completions) |
| **Files** | [`list_files`](#list-files) · [`upload_file`](#upload-file) · [`get_file`](#get-file) · [`delete_file`](#delete-file) · [`process_file`](#process-file) · [`resolve_durable_file_reference`](#resolve-durable-file-reference) |
| **Memories** | [`list_memories`](#list-memories) · [`create_memory`](#create-memory) · [`update_memory`](#update-memory) · [`delete_memory`](#delete-memory) · [`import_memories_text`](#import-memories-text) · [`get_memory_import_status_result`](#get-memory-import-status-result) |
| **Webhooks** | [`list_webhooks`](#list-webhooks) · [`delete_webhook`](#delete-webhook) |
| **Credits & workspace** | [`deduct_credits_user`](#deduct-credits-user) · [`get_workspace_usage`](#get-workspace-usage) |
This list covers every tool relevant to a third-party integration. Folder/chat-organization tools (used internally by the Tess web UI) exist too but aren't documented here — ask your assistant to "list available tools" to see the full, current set from your MCP client directly.
## Before you start
You need two things from the Tess platform:
Generate a personal access token in **[Tess AI → API Tokens](https://tess.im/dashboard/user/tokens)**. This is the same token used across the Tess API — see [Quickstart](https://docs.tess.im/api/get-started/quickstart) for details.
The MCP server is **workspace-scoped**. Find your workspace ID in the Tess dashboard URL or workspace settings, and use the one whose agents you want to reach. Every call is isolated to that workspace.
Treat your API token like a password. It grants access to your workspace's agents and executions, which may consume credits. Prefer a dedicated token per integration so you can revoke it independently.
## Authenticating
Credentials are sent as **HTTP headers only** — never as URL query parameters, so tokens don't end up in logs or browser history:
```
Authorization: Bearer YOUR_API_TOKEN
x-workspace-id: YOUR_WORKSPACE_ID
```
Both headers are required on every request. **Required as of 2026-09-01** for Tess API workspace scoping (same header policy as the REST API). There is no query-parameter fallback — your MCP client must support setting custom headers on the connection.
## Connect your platform
```bash theme={null}
claude mcp add tess --transport http https://mcp.tess.im \
--header "Authorization: Bearer YOUR_API_TOKEN" \
--header "x-workspace-id: YOUR_WORKSPACE_ID"
```
Then, in a session: *"Use Tess to run the Code Review agent on this diff."*
Add Tess to your MCP configuration (in Cursor: **Tools & Integrations → MCP Tools**, or `~/.cursor/mcp.json`):
```json theme={null}
{
"mcpServers": {
"tess": {
"url": "https://mcp.tess.im",
"headers": {
"Authorization": "Bearer YOUR_API_TOKEN",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
}
}
}
```
Add a remote MCP server with headers in `~/.codex/config.toml`:
```toml theme={null}
[mcp_servers.tess]
url = "https://mcp.tess.im"
headers = { Authorization = "Bearer YOUR_API_TOKEN", "x-workspace-id" = "YOUR_WORKSPACE_ID" }
```
Config syntax can change between Codex CLI versions — check `codex mcp --help` or the current Codex docs if this doesn't match what you see.
These platforms connect to remote MCP servers through a "custom connector" UI. To work with Tess, the platform's connector configuration must let you set **two** things:
* The endpoint URL: `https://mcp.tess.im`
* **Two** custom headers: `Authorization: Bearer YOUR_API_TOKEN` and `x-workspace-id: YOUR_WORKSPACE_ID`
Some connector UIs only expose a single bearer-token field and don't support adding a second custom header — check your platform's current documentation for whether custom headers (beyond a bearer token) are supported for remote MCP connectors. If your platform only supports a single auth header, use one of the header-capable clients above (Claude Code, Cursor, Codex CLI) or a custom integration instead.
## How authentication works
The MCP server is a **stateless gateway**. It does not store your credentials. On every request it:
1. Reads your API token and workspace ID from the request headers.
2. Forwards the call to the Tess API **as you**, exactly as a direct API call would.
3. Returns the result to your MCP client.
This means the server inherits **all** of your platform's existing controls:
Calls run with the token owner's identity. Agent visibility, roles, and feature permissions are enforced by Tess, not bypassed.
Every request is bound to the `x-workspace-id` you send. One token cannot reach another workspace's data.
Executions consume credits under your existing workspace limits and billing — the same as the Tess API.
Revoke a token in the dashboard to instantly cut off any connected platform using it. No redeploy needed.
## Tools reference
### list\_agents
Lists agents available in the workspace, with search and pagination.
Search agents by title, description, and long description.Filter by agent type.Page number for pagination.Number of agents per page.
### get\_agent
Returns the full details of a single agent (inputs, type, description).
The agent ID.
### execute\_agent
Runs an agent with the given inputs and, optionally, waits for the result.
The agent ID.The agent's answers. For chat-type agents, include a `messages` array (`role`/`content` pairs, same shape as the OpenAI Chat Completions format).When `true`, waits for the execution to finish and returns the final output. When `false`, returns immediately so you can poll the execution later.
### list\_files\_agent
Gets a list of files associated with a specific agent.
ID of the agent to retrieve files for.
### link\_files\_agent
Associates one or more files with a specific agent.
ID of the agent to link files to.Array of file IDs to link to the agent.
### delete\_file\_link\_agent
Removes the association between a specific file and an agent.
ID of the agent to remove the file link from.ID of the file to unlink from the agent.
### list\_agent\_responses
Lists agent execution responses, with filtering and pagination.
Search agents by title.Filter by root execution ID.Filter by agent ID.Filter by agent type.Sort by ascending or descending (`asc`/`desc`).Current page.Number of items per page.
### get\_agent\_response
Fetches a single agent execution response by ID.
The agent execution ID.
### list\_agent\_webhooks
Lists webhooks registered for a specific agent.
Agent ID.Current page.Number of items per page.
### create\_agent\_webhook
Registers a new webhook on a specific agent.
The agent ID.The webhook target URL.HTTP method used for the webhook call.Webhook status (`active`/inactive).
### agent\_chat\_completions
Runs an agent through an OpenAI-compatible Chat Completions interface — useful for clients already integrated against the OpenAI API shape.
The agent ID.An OpenAI Chat Completions-shaped request body.
### list\_files
Gets a paginated list of files in the workspace, with sorting options.
Page number for pagination.Number of items per page (max 100).Sort order for the `created_at` field (`asc`/`desc`).
### upload\_file
Uploads a new file to the workspace and optionally processes it.
The file to upload.Whether to process the file immediately after upload.
### get\_file
Returns the details of a single file.
The file ID.
### delete\_file
Deletes a file from the workspace.
The file ID.
### process\_file
Triggers (or re-triggers) processing for an already-uploaded file.
The file ID.
### resolve\_durable\_file\_reference
Resolves a durable `doc://` artifact reference (as returned in a `ref_url`) into a freshly minted, short-lived signed download URL. Identity and workspace scope come from your API token.
The durable artifact reference to resolve.
### list\_memories
Lists memories stored in the workspace.
Filter by memory collection.Page number for pagination.Items per page (max 50).
### create\_memory
Saves a new memory to a collection.
The memory collection to store the memory in.The memory text to store (max 32,000 characters).
### update\_memory
Edits an existing memory.
The memory to update.New memory text.Move the memory to a different collection.
### delete\_memory
Removes an existing memory.
The memory to delete.
### import\_memories\_text
Triggers a bulk memory import from free text. Async by default.
Whether to block until the import completes (bounded timeout) instead of returning immediately.
### get\_memory\_import\_status\_result
Returns the status and summary for a memory-import execution.
The import execution ID.
### list\_webhooks
Lists all webhooks in the workspace.
Current page.Number of items per page.
### delete\_webhook
Deletes a webhook by ID.
The webhook ID.
### deduct\_credits\_user
Deducts credits from a specific user based on the credit-system base factor and calculation parameters. Intended for platform-level integrations metering usage of a custom resource.
Identifier for the user/workspace whose credits will be deducted.Type of resource being metered (e.g. `image`).Positive numeric value used for the credit calculation.The workspace ID.ID of the resource being metered.Additional inputs for the credit calculation.
### get\_workspace\_usage
Returns workspace usage broken down by type and date range.
Preset date range filter (`1d`/`7d`/`30d`).Custom start date (`YYYY-MM-DD`). Use with `end_date`; overrides `range`.Custom end date (`YYYY-MM-DD`). Use with `start_date`; overrides `range`.Filter by user ID (requires the `WORKSPACE_DOCUMENTS_READ` permission).Filter by usage type (`chat`, `image`, `text`, `tool_execution`, `connector_calls`, and more).Page number for pagination.
## Example: run an agent end to end
Once connected, you can drive a full workflow in natural language:
*"List my Tess agents"* → the assistant calls [`list_agents`](#list-agents) and shows what's available.
*"Save to my 'Engineering Standards' collection: always write unit tests with BDD"* → [`create_memory`](#create-memory).
*"Use the Code Review agent to review this function, and wait for the result"* → [`execute_agent`](#execute-agent) returns the output inline.
*"List my memories"* → [`list_memories`](#list-memories) confirms what's stored for future runs.
## Governance & compliance
* **Least privilege** — connect with a token scoped to a single workspace and only the permissions that integration needs.
* **Auditability** — executions triggered through MCP appear in your Tess workspace history and usage, just like any API call.
* **No credential storage** — the gateway is stateless; tokens live only in your MCP client's configuration.
* **Centralized revocation** — disabling a token in the dashboard immediately blocks every platform using it.
## Troubleshooting
Confirm your client uses the **Streamable HTTP** (remote) transport rather than a local/stdio command, and that it's pointed at `https://mcp.tess.im` directly (no extra path).
Both headers are required on every request — `Authorization: Bearer YOUR_API_TOKEN` and `x-workspace-id: YOUR_WORKSPACE_ID`. There is no URL query-parameter option; confirm your client supports setting custom headers, and that the token is active in the dashboard.
The workspace ID is missing, malformed, or the token doesn't have access to it. Confirm the `x-workspace-id` header is set and matches a workspace your token can access.
Some agents require specific inputs. Chat-type agents, for example, expect a `messages` array in `body`. Ask the assistant to inspect the agent's fields ([`get_agent`](#get-agent)), or check the agent in the Tess platform.
## Resources
* [Model Context Protocol — official site](https://modelcontextprotocol.io)
* [How to create an API Token in Tess AI](https://docs.tess.im/api/get-started/quickstart)
# Public Pages
Source: https://docs.tess.im/en/artifacts
Public Pages are pages published directly from Tess. They allow you to transform content generated in chats — such as guides, analyses, landing pages, or documentation — into shareable links, ready for external access. It’s the fastest way to move beyond the “chat” and put something live.
Public Pages were previously called Artifacts.
### **What are they?**
Public Pages are published outputs from Tess with their own hosting.
In practice, any structured content on the platform can be turned into a public link. This eliminates the need to export text to other publishing tools (such as a CMS or website builder). They act as a bridge between your creation environment (AI) and the final delivery to clients or your team.
### **Where to find them?**
Access Public Pages through the settings menu after clicking on your user icon:
### **How to use them?**
1. Generate the content: In the Tess AI chat, ask it to create a page, guide, or analysis.
2. Turn it into a Public Page: Ask the AI to structure the final format (e.g., "turn this into a page for publication") and use the publishing feature in the chat.
3. Access management: Go to the sidebar → Workspace → Public Pages.
4. Copy and share: Click on the generated link (format `tess.page`) and send it to whoever needs it.
5. Control publication: If you need to take the page offline, simply click on the green status label Public. It will unpublish the page instantly. To publish it again, click the same button.
### **Deeper explanation**
Public Pages work as a simplified deployment layer within Tess.
Instead of:
* Exporting content
* Uploading it to a CMS
* Configuring hosting
You publish directly from the AI.
Each public page:
* Is linked to a source chat
* Can be reopened and iterated
* Maintains a stable link (ideal for sharing)
This makes the cycle create → adjust → publish → share extremely fast.
### Practical examples
#### 1. Create a simple landing page
> Prompt: "Create a landing page for a SaaS CRM product for small businesses. Structure it with a headline, benefits, social proof, and CTA."
>
> Then: "Turn this into a publishable page"
#### 2. Share an analysis with a client
> Prompt: "Analyze this sales data and generate an executive report with insights and recommendations"
>
> Then: "Format this as a clear page to share with a client"
Best practices
* Structure before publishing Ask the AI to organize the content with titles, sections, and clear hierarchy.
* Review the final content Once published, the link can be accessed by anyone.
* Use for fast deliverables Ideal for materials that need to be shared without friction.
* Standardize publishing prompts Example: “format as a clean page, with well-defined sections and ready for publication”.
* Leverage the chat connection If you need to change something, go back to the original chat and generate a new version.
### Important notes
* Published public pages are accessible via a public link, so avoid including sensitive or confidential data.
* The default domain is `tess.page`
Public Pages transform Tess into a delivery tool, not just a creation tool. In just a few steps, you go from a prompt to a shareable link — ideal for those who need to produce and distribute content quickly.
# Context Window Control
Source: https://docs.tess.im/en/context-window-control
The context window defines how much of the conversation history the AI considers in each response. In Tess, this control is done by the Memory Economy Mode, which allows balancing quality vs credit consumption.
This context control allows you to define how many tokens Tess AI can consider in each chat conversation that is opened. This directly impacts chat memory, response quality, and credit consumption.
### What is it?
It is the setting that defines the “active memory size” of the model in each execution.
In practice, the larger the context:
* The more history the model considers
* The higher the cost per execution
Memory Economy Mode allows adjusting this dynamically, prioritizing economy or depth.
### **Before using: what you need to know**
Before changing this setting, it is worth understanding some important points:
1. It is a per-user setting: Each user defines their own preference and their choice does not automatically alter the experience of other Workspace members
2. It is a global setting of your experience in Tess: It does not apply only to a single chat, the adjustment starts to influence your conversations on the platform in general, nor does it become a “per Prompt” setting.
3. You don't need to reset this for every new conversation: Once adjusted, the preference remains active until you change it again, the main goal is to balance quality and cost
More context improves history retention. Less context reduces token spending, especially in long chats
### **Where to find it?**
In the bottom left corner, click on your user icon and access the settings > preferences option.
Scroll down to the memory economy configuration option.
* Further right → more economy
* Further left → more context (e.g., the default and the 32K token window)
### **How to interpret Memory Economy Mode**
Memory Economy Mode works as a control between economy and context depth.
Tess limits the quantity of tokens per message more strongly. In practice, the cost tends to drop, the useful history that the LLM will use from the conversation gets smaller, long chats might lose continuity earlier. The default setting is 32K tokens, 43% credit saving.
Tess expands the available limit per message. In practice, more history can be considered by the LLM, the continuity tends to improve and the input cost (input token) tends to go up, after all, it is much more content being reviewed by the text model to compose its memory.
On the interface itself, you will see indicators such as:
* estimated percentage of credit savings
* approximate context limit, such as 32K tokens
These numbers help to understand the trade-off between economy and depth.
### **How this works in practice**
Generally speaking, this setting is more relevant in long conversations. In a short chat, the difference might be small. However, in a chat that accumulates a lot of history, the context limit becomes more important, because the model cannot consider everything indefinitely.
This means that, in extensive conversations:
* with less context, older parts may cease to be considered
* with more context, continuity tends to be better
* with Memory Boost active, Tess can retrieve relevant excerpts of the history even while keeping a more economical limit
The context window is not just a technical setting. It changes the actual behavior of the AI over the course of its use.
In Tess, Memory Economy Mode limits the quantity of context tokens per message.
This means that the platform controls how much history will effectively be sent to the model with each new interaction.
This point is important because many users assume that the model always “remembers everything” within the chat. In practice, this is not the case: there is a technical context limit per execution.
> **Therefore, adjusting the Memory Economy Mode works as an individual usage policy:** *you decide to prioritize either more economy or more history retention. This control is especially useful for those who want to scale the use of Tess with more cost predictability.*
Additionally, the set limit impacts all messages in the chat and models that are used to converse. However, when activating Max Mode, the model ignores this setting and uses the native maximum limit of each model.
### **Practical examples of context and settings**
**Example 1: fast and operational use**
If you use Tess for tasks like reviewing short texts, answering objective questions or generating small content variations, for example, a more economical mode is usually sufficient.
> Prompt example:\
> *"Rewrite this paragraph in a more professional tone."*
>
> In this case, there is no need to keep much of the conversation history.
**Example 2: strategic and continuous conversation**
If you are using Tess to build a plan throughout several interactions
mature an analysis or work on a project with accumulated context, a larger context tends to work better.
> Prompt example:\
> *"Consider everything we have discussed so far and organize a final proposal in topics."*
>
> Here, continuity makes a difference in the result, it may be important to review your maximum limit.
**Best practices**
* Use high economy for: repetitive tasks, short Prompts
* Use more context for: complex analyses, long conversations
* Combine with Memory Boost to optimize cost
* Review this setting if you notice: responses “forgetting context” or overly high cost
**Important notes**
* More context = higher consumption of credits
* Less context can make the AI “forget” parts of the conversation
* The impact is greater in long chats
* The displayed value (e.g., 32K tokens) is an approximate limit
### **Common mistakes**
1. Leaving context high for everything: This increases the cost even in simple tasks that do not need a long history.
2. Leaving context too low in strategic chats: This can harm continuity and generate less consistent responses throughout the conversation.
3. Treating this setting as something per chat: The adjustment is made in the user's preferences and broadly influences the experience on the platform.
4. Ignoring the impact on credits: The more context is used per message, the higher the input cost tends to be in long conversations.
The context window is one of the most important settings for balancing response quality, conversation continuity, and credit consumption in Tess AI.
Since it is set per user and affects your experience on the platform as a whole, it is worth adjusting this preference consciously — especially if you use Tess frequently or in long conversations. By adjusting it correctly, you can balance response quality and operational cost simply.
# Create Agent Webhook
Source: https://docs.tess.im/en/create-agent-webhook
POST https://api.tess.im/agents/{id}/webhooks
Create a new webhook for a specific agent.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/{id}/webhooks' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"url": "https://example.com/webhook",
"method": "POST",
"status": "active"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
url: 'https://example.com/webhook',
method: 'POST',
status: 'active'
};
const config = {
method: 'post',
url: 'https://api.tess.im/agents/{id}/webhooks',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: data
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/agents/{id}/webhooks"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
data = {
"url": "https://example.com/webhook",
"method": "POST",
"status": "active"
}
response = requests.post(url, headers=headers, json=data)
print(response.json())
```
```php PHP theme={null}
'https://example.com/webhook',
'method' => 'POST',
'status' => 'active'
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/agents/{id}/webhooks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String data = "{\"url\":\"https://example.com/webhook\",\"method\":\"POST\",\"status\":\"active\"}";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{id}/webhooks"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(data))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"url": "https://example.com/webhook",
"method": "POST",
"status": "active",
}
jsonData, err := json.Marshal(data)
if err != nil {
fmt.Println(err)
return
}
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/agents/{id}/webhooks", bytes.NewBuffer(jsonData))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = new StringContent(
"{\"url\":\"https://example.com/webhook\",\"method\":\"POST\",\"status\":\"active\"}",
Encoding.UTF8,
"application/json"
);
try
{
var response = await client.PostAsync("https://api.tess.im/agents/{id}/webhooks", data);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/{id}/webhooks')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
url: 'https://example.com/webhook',
method: 'POST',
status: 'active'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
### **Body Parameters**
The URL that will receive webhook notifications
The HTTP method to use for the webhook (POST)
The status of the webhook (active or inactive)
### **Response**
```json theme={null}
{
"template_id": 8794,
"user_id": 0,
"url": "https://webhook.site/3bea4d55-0734-4bbd-aab9-95639585e539",
"method": "POST",
"status": "active",
"updated_at": "2025-01-05T23:35:20.000000Z",
"created_at": "2025-01-05T23:35:20.000000Z",
"id": 18
}
```
# Create Memory Collection
Source: https://docs.tess.im/en/create-collection
POST https://api.tess.im/memory-collections
Creates a new memory collection.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/memory-collections' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"name": "My Collection"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
name: "My Collection"
};
const config = {
method: 'post',
url: 'https://api.tess.im/memory-collections',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: data
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/memory-collections"
payload = {
"name": "My Collection"
}
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
"My Collection"
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/memory-collections",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String requestBody = "{\"name\":\"My Collection\"}";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memory-collections"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"name": "My Collection"
}
jsonData, err := json.Marshal(data)
if err != nil {
fmt.Println(err)
return
}
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/memory-collections", bytes.NewBuffer(jsonData))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var requestData = new
{
name = "My Collection"
};
var content = new StringContent(
System.Text.Json.JsonSerializer.Serialize(requestData),
Encoding.UTF8,
"application/json"
);
try
{
var response = await client.PostAsync("https://api.tess.im/memory-collections", content);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memory-collections')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
name: 'My Collection'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Request Body**
Name of the collection
### **Response**
```json theme={null}
{
"message": "Collection created successfully",
"collection": {
"user_id": 1,
"name": "string",
"id": 2
}
}
```
# Create Memory
Source: https://docs.tess.im/en/create-memory
POST https://api.tess.im/memories
Creates a new memory.
### **Code Examples**
```http cURL theme={null}
curl -X POST "https://api.tess.im/memories" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H 'x-workspace-id: YOUR_WORKSPACE_ID' \
-H "Content-Type: application/json" \
-d '{
"collection_id": 1,
"memory": "Example memory content"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const url = 'https://api.tess.im/memories';
const headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
};
const data = {
collection_id: 1,
memory: 'Example memory content'
};
axios.post(url, data, { headers })
.then(response => console.log(response.data))
.catch(error => console.error(error));
```
```python Python theme={null}
import requests
url = "https://api.tess.im/memories"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
payload = {
"collection_id": 1,
"memory": "Example memory content"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
1,
"memory" => "Example memory content"
];
$headers = [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
];
$curl = curl_init($url);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
echo $response;
?>
```
```java Java theme={null}
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class CreateMemory {
public static void main(String[] args) {
try {
URL url = new URL("https://api.tess.im/memories");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
connection.setRequestProperty("x-workspace-id", "YOUR_WORKSPACE_ID");
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true);
String jsonInput = "{\"collection_id\":1,\"memory\":\"Example memory content\"}";
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInput.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length);
}
int responseCode = connection.getResponseCode();
try (Scanner scanner = new Scanner(connection.getInputStream(), StandardCharsets.UTF_8.name())) {
String responseBody = scanner.useDelimiter("\\A").next();
System.out.println(responseBody);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.tess.im/memories"
data := map[string]interface{}{
"collection_id": 1,
"memory": "Example memory content",
}
jsonData, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.tess.im/memories";
var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = new
{
collection_id = 1,
memory = "Example memory content"
};
var json = JsonConvert.SerializeObject(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var responseContent = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseContent);
}
}
```
```ruby Ruby theme={null}
require 'net/http'
require 'uri'
require 'json'
uri = URI.parse('https://api.tess.im/memories')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
collection_id: 1,
memory: 'Example memory content'
}.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
http.request(request)
end
puts response.body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Request Body Parameters**
Collection ID
Memory content (max 32000 characters)
### **Success Response**
```json theme={null}
{
"message": "Memory created successfully!",
"memory": {
"id": 1,
"user_id": 1,
"collection_id": 1,
"memory": "Example memory content",
"credits": 0
}
}
```
### **Error Responses**
#### **Validation Error (422)**
```json theme={null}
{
"message": "Validation error message"
}
```
#### **Server Error (500)**
```json theme={null}
{
"message": "Error message",
"error": "Error details"
}
```
# Create Teams in Tess
Source: https://docs.tess.im/en/create-teams
Learn how to structure your company's organizational chart within Tess. Group your collaborators into teams or departments to simplify the application of usage policies, credit limits, and access all at once, eliminating the need to configure users one by one.
### What is it?
The Teams feature allows you to organize users in your workspace in a logical and hierarchical way (e.g., Marketing, Finance, Technology, CS). Instead of managing each employee’s rules individually, you create global rules for the Team — such as which AI models they can use and the group’s monthly credit budget.
Anyone assigned to this group will automatically inherit the configured permissions, such as:
* AI models authorized for use.
* Allowed data connectors (e.g., Google Drive, Notion, etc.).
* Maximum monthly quota of shared or individual team credits.
**Where to find it**
It is important that you are logged in and that you are the workspace owner or a member with this permission.
After clicking on your user icon, access settings and then members.
### **How to configure the team**
1. With the creation modal open, enter the group’s descriptive name in Team name (e.g., "Executive Marketing", "Tech Developers").
2. In the Type field, select the group classification (e.g., Team or Department).
3. In Part of (optional), you can define a hierarchy. If this group is subordinate to another, select the parent team (e.g., the "Performance" team is part of the "Marketing" department).
4. Scroll down to the Advanced governance settings tab to define how this group operates:
* **Connector access:** Select whether this team can use all available connectors or restrict it to only allowed ones.
* **AI model access:** Define whether the group will have free access to run any AI model or be limited to specific models relevant to their work.
* **Monthly credit limit:** Set a credit consumption cap for the group.
5. Click Create.
### **Understanding the Hierarchy ("Part of")**
When creating organizational structures in Tess, you can nest teams:
```text theme={null}
[Department] Commercial
└── [Team] Inside Sales
└── [Team] Field Sales
```
Defining the "Parent Team" allows you to replicate governance rules from top to bottom in a simplified way, organizing records and monthly usage reports in a corporate manner.
* **Horizontal Structure (No Parent):** The team is autonomous. It has its own rules, which neither affect nor are affected by other groups. Ideal for small companies or areas with completely separate operations.
* **Vertical Structure (Part of...):** Useful for consolidating corporate governance. A child team (e.g., Chat Support) inherits the base policies of the parent team (e.g., Customer Experience). This ensures security in corporate data access and prevents junior analysts from accessing connectors beyond their scope.
### Practical examples
* Setting up a Writing Team (Focus on Text AI):
* Configuration:
* *Team Name:* SEO Writers
* *Connector access:* Blocked (or only Google Docs allowed)
* *AI model access:* Allow only text-focused models with large context windows (e.g., Claude 3.5 Sonnet, GPT-4o Mini)
* *Credit Limit:* 100,000 credits/month per team user
**Best practices**
* **Standardized naming:** Use clear patterns to organize listings (e.g., \[Department] - \[Role] -> CS - Analyst or Sales - SDR).
* **Structure before inviting:** Create your workspace’s core teams before generating invitation links for collaborators. This way, you can assign them to the correct groups as soon as they accept the invite.
* **Restrict sensitive data connectors:** Avoid leaving connector access set to "All available connectors" for teams composed of new employees, external contractors, or freelancers.
### Important notes
* Rule inheritance: Any new member added to this team will instantly assume all the limitations and access defined in the advanced governance settings.
* Impact on consumption: The limit set for the team is recalculated at the beginning of each contractual billing cycle of your account.
*Individual restrictions applied to a user override, fully or partially, the policies defined in the team they belong to!*
Therefore, structuring teams in Tess AI removes the operational friction of managing dozens of users manually, combining technical decentralization with centralized cost control.
If you have questions or need support, contact our team via email: [support@tess.im](mailto:support@tess.im)
# Data Control
Source: https://docs.tess.im/en/data-control
The Data Controls area brings together everything you need to know about security, privacy, and availability of Tess AI. Here you can access the Trust Center (with certifications and policies) and the System Status (real-time uptime monitoring and incidents).
### **What you'll find in this area**
\
The Trust Center consolidates Tess AI's security practices and certifications across five main pillars:
Protection of the servers and environments where Tess operates, access controls, redundancy, backup and disaster recovery, etc.
Internal security governance policies, audit and continuous review processes, etc.
Secure development practices (secure coding, code review, vulnerability testing), security updates and patches, among others.
Threat monitoring routines, incident response, and others.
Compliance with LGPD, GDPR, and other data protection regulations. Policies for data collection, storage, use, and disposal, among others.
**Why access the Trust Center?**
1. Transparency: see how Tess protects your data and operations
2. Compliance: useful for internal audits, information security, and regulatory compliance
3. Trust: essential for IT, security, legal, and privacy teams that are evaluating or already using Tess
\
The System Status shows, in real time, the operational health of the Tess AI platform:
* Current uptime (service availability)
* Ongoing incidents or recent history
* Performance of APIs and main features
**Why access the System Status?**
If you're experiencing slowness or an error, you can check whether it's a general or local issue and have transparent visibility into incidents (start, resolution, impact).
In summary, Data Controls ensure full transparency about how Tess protects your data (Trust Center) and keeps the platform running with high availability (System Status).
Access it whenever you need to verify security, assess compliance, or check if there is any ongoing incident.
# Delete Memory Collection
Source: https://docs.tess.im/en/delete-collection
DELETE https://api.tess.im/memory-collections/{collectionId}
Deletes a memory collection and all associated memories.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url 'https://api.tess.im/memory-collections/{collectionId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'delete',
url: 'https://api.tess.im/memory-collections/{collectionId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/memory-collections/{collectionId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/memory-collections/{collectionId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memory-collections/{collectionId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("DELETE", "https://api.tess.im/memory-collections/{collectionId}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.DeleteAsync("https://api.tess.im/memory-collections/{collectionId}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memory-collections/{collectionId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
Collection ID
### **Response**
```json theme={null}
{
"message": "Collection deleted successfully"
}
```
### **Error Responses**
#### **Collection not found (404)**
```json theme={null}
{
"message": "Collection not found"
}
```
#### **Cannot delete default collection (403)**
```json theme={null}
{
"message": "Default collection cannot be deleted"
}
```
# Delete File
Source: https://docs.tess.im/en/delete-file
DELETE https://api.tess.im/files/{fileId}
Delete a specific file by its ID.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url 'https://api.tess.im/files/{fileId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'delete',
url: 'https://api.tess.im/files/{fileId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/files/{fileId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/files/{fileId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/files/{fileId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("DELETE", "https://api.tess.im/files/{fileId}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.DeleteAsync("https://api.tess.im/files/{fileId}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/files/{fileId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the file to delete
### **Response**
```json theme={null}
{
"id": "73325",
"object": "file",
"deleted": true
}
```
# Delete Memory
Source: https://docs.tess.im/en/delete-memory
DELETE https://api.tess.im/memories/{memoryId}
Deletes an existing memory.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url 'https://api.tess.im/memories/{memoryId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const memoryId = 123;
const options = {
method: 'DELETE',
url: `https://api.tess.im/memories/${memoryId}`,
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
axios.request(options)
.then(response => {
console.log(response.data);
})
.catch(error => {
console.error(error);
});
```
```python Python theme={null}
import requests
memoryId = 123
url = f"https://api.tess.im/memories/{memoryId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/memories/{$memoryId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error: " . $err;
} else {
echo $response;
}
?>
```
```java Java theme={null}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class DeleteMemory {
public static void main(String[] args) {
int memoryId = 123;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memories/" + memoryId))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
.thenApply(HttpResponse::body)
.thenAccept(System.out::println)
.join();
}
}
```
```go Go theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
memoryId := 123
url := fmt.Sprintf("https://api.tess.im/memories/%d", memoryId)
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
int memoryId = 123;
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "YOUR_API_KEY");
var response = await client.DeleteAsync($"https://api.tess.im/memories/{memoryId}");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
memoryId = 123
url = URI("https://api.tess.im/memories/#{memoryId}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["Authorization"] = "Bearer YOUR_API_KEY"
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
ID of the memory
### **Response**
```json theme={null}
{
"message": "Memory deleted successfully!"
}
```
### **Response Codes**
| **Status Code** | **Description** |
| :-------------- | :--------------- |
| 200 | Success |
| 404 | Memory not found |
| 500 | Server error |
### **Error Responses**
#### **404 Not Found**
```json theme={null}
{
"message": "Memory not found!"
}
```
#### **500 Server Error**
```json theme={null}
{
"message": "Memory deletion failed!",
"error": "Error message details"
}
```
# Delete Webhook
Source: https://docs.tess.im/en/delete-webhook
DELETE https://api.tess.im/webhooks/{id}
Deletes a specific webhook by ID.
### **Code Examples**
```http cURL theme={null}
curl --request DELETE \
--url 'https://api.tess.im/webhooks/{id}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'delete',
url: 'https://api.tess.im/webhooks/{id}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/webhooks/{id}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.delete(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/webhooks/{id}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/webhooks/{id}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.DELETE()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("DELETE", "https://api.tess.im/webhooks/{id}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.DeleteAsync("https://api.tess.im/webhooks/{id}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/webhooks/{id}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The webhook ID
### **Response**
```json theme={null}
{
"message": "Webhook deleted successfully"
}
```
# Get Agent Version
Source: https://docs.tess.im/en/get-agent-version
GET https://api.tess.im/agents/{id}/versions/{version_number}
Returns the complete snapshot of a specific agent version, including all configuration fields at the time that version was saved. Requires the `agent:version:read` permission.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents/8794/versions/2' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents/8794/versions/2',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/8794/versions/2"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/8794/versions/2",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/8794/versions/2"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents/8794/versions/2", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents/8794/versions/2");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/8794/versions/2')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
The version ID to retrieve
### **Response**
```json theme={null}
{
"version": {
"version_id": 7,
"published_at": "2026-04-06T13:52:19+00:00",
"published_by": "user@example.com",
"rollback_from_version": 2,
"snapshot": {
"agent_name": "Customer Support Agent",
"instructions": "You are a helpful customer support assistant.",
"ask_user_questions": [
{
"name": "topic",
"type": "text",
"description": "What topic do you need help with?",
"required": true,
"tooltip": ""
}
],
"steps": [],
"knowledge_base_files": [],
"type": "chat",
"subtype": "All LLM Models",
"advanced_settings": {
"model": "auto",
"temperature": "1"
},
"visibility": "private"
}
}
}
```
### **Response Fields**
| **Field** | **Type** | **Description** |
| :-------------------------------------- | :--------------- | :-------------------------------------------------------------------------- |
| version.version\_id | integer | Unique sequential identifier for this version |
| version.published\_by | string | Email of the user who saved this version |
| version.published\_at | string (ISO8601) | Timestamp when this version was created |
| version.rollback\_from\_version | integer \| null | If created by a rollback, the source `version_id`; otherwise `null` |
| version.snapshot.agent\_name | string | Agent name at the time this version was saved |
| version.snapshot.instructions | string | System prompt / instructions at the time this version was saved |
| version.snapshot.ask\_user\_questions | array | User input fields configured at the time this version was saved |
| version.snapshot.steps | array | Automation steps configured at the time this version was saved |
| version.snapshot.knowledge\_base\_files | array | Knowledge base files linked at the time this version was saved |
| version.snapshot.type | string | Agent type (e.g., `chat`) |
| version.snapshot.subtype | string | Agent subtype (e.g., `All LLM Models`) |
| version.snapshot.advanced\_settings | object | Model and temperature settings at the time this version was saved |
| version.snapshot.visibility | string | Agent visibility (`private` or `public`) at the time this version was saved |
### **Error Responses**
#### **Not Found (404)**
```json theme={null}
{
"message": "Version not found."
}
```
#### **Forbidden (403)**
```json theme={null}
{
"message": "You do not have permission to view agent versions."
}
```
# Get File
Source: https://docs.tess.im/en/get-file
GET https://api.tess.im/files/{fileId}
Retrieve a specific file by its ID.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/files/{fileId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/files/{fileId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/files/{fileId}"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/files/{fileId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/files/{fileId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/files/{fileId}", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/files/{fileId}");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/files/{fileId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the file to retrieve
### **Response**
```json theme={null}
{
"id": 73325,
"object": "file",
"created_at": "2025-01-05T22:26:27+00:00",
"bytes": 35504128,
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
}
```
# List Agent Webhooks
Source: https://docs.tess.im/en/list-agent-webhooks
GET https://api.tess.im/agents/{id}/webhooks
List all webhooks for a specific agent.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/agents/{id}/webhooks' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/agents/{id}/webhooks',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/{id}/webhooks"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/{id}/webhooks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/{id}/webhooks"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/agents/{id}/webhooks", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/agents/{id}/webhooks");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/{id}/webhooks')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
### **Query Parameters**
Current page (default: 1)
Number of items per page (default: 15)
### **Response**
```json theme={null}
{
"current_page": 1,
"data": [
{
"id": 18,
"template_id": 8794,
"user_id": 0,
"url": "https://webhook.site/3bea4d55-0734-4bbd-aab9-95639585e539",
"method": "POST",
"success_count": 0,
"failure_count": 0,
"status": "active",
"created_at": "2025-01-05T23:35:20.000000Z",
"updated_at": "2025-01-05T23:35:20.000000Z",
"deleted_at": null
}
],
"first_page_url": "https://api.tess.im/agents/8794/webhooks?page=1",
"from": 1,
"last_page": 1,
"last_page_url": "https://api.tess.im/agents/8794/webhooks?page=1",
"links": [
{
"url": null,
"label": "pagination.previous",
"active": false
},
{
"url": "https://api.tess.im/agents/8794/webhooks?page=1",
"label": "1",
"active": true
},
{
"url": null,
"label": "pagination.next",
"active": false
}
],
"next_page_url": null,
"path": "https://api.tess.im/agents/8794/webhooks",
"per_page": 15,
"prev_page_url": null,
"to": 1,
"total": 1
}
```
# List Collections
Source: https://docs.tess.im/en/list-collections
GET https://api.tess.im/memory-collections
Retrieves a paginated list of memory collections for the authenticated user.
### **Code Examples**
Want to learn how to use memory collections in agent API calls? See the [complete Memories guide](/en/memories#using-memories-via-api) for the 3-step flow: create a collection, add memories, and execute the agent with `memory_collections`.
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/memory-collections?page=1&per_page=10&search=example' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/memory-collections?page=1&per_page=10&search=example',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/memory-collections"
params = {
"page": 1,
"per_page": 10,
"search": "example"
}
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, params=params, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/memory-collections?page=1&per_page=10&search=example",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memory-collections?page=1&per_page=10&search=example"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/memory-collections?page=1&per_page=10&search=example", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/memory-collections?page=1&per_page=10&search=example");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memory-collections')
params = { page: 1, per_page: 10, search: 'example' }
uri.query = URI.encode_www_form(params)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Query Parameters**
Page number 1 - -
Items per page 10 1 50
Search term to filter collections - - -
### **Response**
```json theme={null}
{
"message": "success",
"collections": [
{
"id": 1,
"user_id": 1,
"name": "default",
"display_name": "My Memories"
}
],
"meta": {
"current_page": 1,
"last_page": 1,
"total": 1
}
}
```
# List Files
Source: https://docs.tess.im/en/list-files
GET https://api.tess.im/files
Retrieve a paginated list of files with sorting options.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/files' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/files',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/files"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/files",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/files"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/files", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/files");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Query Parameters**
Page number for pagination (default: 1, minimum: 1)
Number of items per page (default: 15, maximum: 100, minimum: 1)
Sort order for created\_at field (default: desc, enum: \[asc, desc])
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Response**
```json theme={null}
{
"data": [
{
"id": 73325,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:26:27+00:00",
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
},
[...]
]
}
```
# List Memories
Source: https://docs.tess.im/en/list-memories
GET https://api.tess.im/memories
Retrieves a paginated list of memories for the authenticated user.
### **Code Examples**
Want to learn how to use memories in agent API calls? See the [complete Memories guide](/en/memories#using-memories-via-api) for the 3-step flow: create a collection, add memories, and execute the agent with `memory_collections`.
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/memories' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/memories',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/memories"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/memories",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memories"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/memories", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/memories");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memories')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Query Parameters**
Page number 1 - -
Items per page 10 1 50
Filter by collection ID - - -
### **Response**
```json theme={null}
{
"message": "Memories fetched successfully!",
"memories": [
{
"id": 9,
"user_id": 1,
"memory": "Example memory content",
"credits": 0,
"collection_id": 1
}
],
"meta": {
"current_page": 1,
"last_page": 2,
"total": 8
}
}
```
# List Webhooks
Source: https://docs.tess.im/en/list-webhooks
GET https://api.tess.im/webhooks
Returns a paginated list of webhooks.
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/webhooks' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/webhooks',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/webhooks"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/webhooks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/webhooks"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/webhooks", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/webhooks");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/webhooks')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Query Parameters**
Current page (default: 1)
Number of items per page (default: 15)
### **Response**
```json theme={null}
{
"current_page": 1,
"data": [
{
"id": 19,
"template_id": 8794,
"user_id": 0,
"url": "https://webhook.site/3bea4d55-0734-4bbd-aab9-95639585e539",
"method": "POST",
"success_count": 0,
"failure_count": 0,
"status": "active",
"created_at": "2025-01-05T23:49:03.000000Z",
"updated_at": "2025-01-05T23:49:03.000000Z",
"deleted_at": null
}
],
"first_page_url": "https://api.tess.im/webhooks?page=1",
"from": 1,
"last_page": 1,
"last_page_url": "https://api.tess.im/webhooks?page=1",
"links": [
{
"url": null,
"label": "pagination.previous",
"active": false
},
{
"url": "https://api.tess.im/webhooks?page=1",
"label": "1",
"active": true
},
{
"url": null,
"label": "pagination.next",
"active": false
}
],
"next_page_url": null,
"path": "https://api.tess.im/webhooks",
"per_page": 15,
"prev_page_url": null,
"to": 1,
"total": 1
}
```
# Integration with Make
Source: https://docs.tess.im/en/make
### **What is Make?**
Make is a visual automation platform that allows you to connect different apps and services to automate workflows without the need for coding. With an intuitive interface, Make makes it easy to create complex integrations between various tools.
### **Benefits of integrating Tess with Make**
* Automate processes between Tess and hundreds of other apps supported by Make.
* Reduce manual tasks and increase productivity.
* Create custom workflows to meet your business needs.
* Gain flexibility to easily scale your operations.
When calling the Tess API from this integration, include `x-workspace-id` (**required as of 2026-09-01**). See [API Overview](/en/api-overview).
# Max Subtasks per Prompt
Source: https://docs.tess.im/en/max-subtasks
The Max Subtasks per Prompt is the setting that defines the platform’s level of autonomy (agentic AI) in each interaction. It establishes the maximum limit of consecutive actions (subtasks) that an agent can execute independently from a single command, before finishing the work or asking permission to continue. It is the definitive tool for balancing deep work (Deep Work) and credit management.
**What is it?**
Tess is not just a text chat; it is a platform operated by autonomous agents. This means that, from your command, the AI can chain multiple tools to achieve a complex objective — such as generating images and videos, performing advanced searches on Google, running and debugging code, reading websites, or even structuring virtual machines (VMs). Each tool execution counts as a subtask.
While the limit of conventional platforms (such as ChatGPT on OpenAI) is usually set at 1 task at a time, in Tess you can configure the same model to execute from 1 up to 40 consecutive subtasks. The Max Subtasks slider tells the AI how far and deep it is allowed to go on its own in a single run.
**Where to find it?**
1. In the left sidebar menu, click on your profile, then on settings and preferences
2. The Max Subtasks per Prompt control will be the first options block on the screen.
1. In the Max Subtasks per Prompt block, locate the purple slider button.
2. Drag the control to the left to limit autonomy (minimum of 1) or to the right to expand it (maximum of 40). The exact value chosen will appear highlighted on the dark button to the right of the bar (e.g.: 25).
3. Done! Just close the window and continue using Tess.
### **Understanding details**
Whenever the AI understands that it needs an external Tool (such as consulting Google Search or opening Python to run code), it opens a subtask. If it tries to run code, gets an error, researches the solution, rewrites the code, and executes it successfully, it consumed several subtasks and, consequently, processed and transacted new tokens at each step.
The limit you configure applies strictly per prompt, not to the entire conversation. Higher values (such as 30 or 40) ensure that the AI is not interrupted in the middle of a huge research task. However, if the AI reaches the exact number of actions you defined in the slider and the task is still not completed, it will pause processing and a message will appear asking if you want it to continue the work from where it stopped.
### **Practical examples**\\
1. Deep Research Task (Ideal: High | 20 to 40 Subtasks)
> *"Research the 5 main CRM solutions for b2b sales teams, extract the pricing tables from each of their websites, generate a comparison report in Excel, and deliver it to me for download."*
**Why:** The AI will need multiple robust actions (searching the web several times, extracting complex data, using the Python file builder, reviewing the data). If the limiter were set to 5, it would pause shortly after visiting the second site.
2. Quick Generation or Text Analysis (Ideal: Low | 1 to 5 Subtasks)\\
> "Create an executive summary of this document I attached and create an abstract cover image based on the content, using corporate blue colors."\\
**Why:** It requires only two concrete actions (reading the provided document and calling the image creation tool). Keeping the limit low for these routine tasks prevents a hallucination (context guessing) from making the AI open unnecessary tools, wasting your credits.
**Best practices**
* Context is king: Max Subtasks enhances the AI. If set to the maximum (40) in an ambiguous prompt, the AI may spend dozens of subtasks researching in redundant directions trying to guess what you want. Always be extremely specific in long prompts.
* Dynamic micromanagement: Build the habit of adjusting this slider depending on the day or the level of demand of the task you are about to delegate.
* Smart association: Combine high Subtasks limits with aggressive limits in Memory Economy Mode. This allows the AI to perform complex tasks focused on the current prompt, without dragging and rereading a thousand pages of history for each new subtask.
### **Important notes**
* Risk of Accelerated Spending: More subtasks running generate more actions and consume more tokens from your credit allowance.
* Does not block the project: The AI’s final window asking if you want to "continue" is native to the system. You will never lose the work done up to that point if that prompt’s subtask package ends.
The Max Subtasks per Prompt is the feature that turns Tess into a true digital employee. By adjusting this parameter strategically, you adapt the tool exactly to the need of the moment: quick and economical responses or projects with high interconnected operational cycles.
# Members and Permissions
Source: https://docs.tess.im/en/members-permissions
Think of the "Members" area as your team's control room in Tess. This is where you have visibility and control to manage who is part of your workspace, each person's teams, how they use the platform, and what permissions and restrictions they have.
This complete guide will show you how to add, manage, and define permissions for your team members.
But before you start, for a better experience, make sure your workspace is already customized. If you haven’t done this yet, check out our article on how to set up your workspace.
### **Default User Types and Permission Levels**
In Tess, there are different default roles you can assign to members, each with a specific set of permissions. Understanding these roles is essential for effective and secure management.
Current Plans - PRO, Business and Enterprise Plans
| User Type | Access and Permissions | Notes |
| :-------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------ |
| Owner | Full access to all features: member management, usage history, data, and full control over subscription and billing. | Usually the workspace creator. Has the highest responsibility and control. |
| Manager | Can invite/manage members and access execution history and credit consumption for everyone. Cannot change or view subscription/billing information. | Ideal for team leaders who need to manage the team and usage, but not financial aspects. **(Legacy Business Plan)** |
| Guest | Free access to use all AI models, access all areas of the platform, create agents, and access agents already created in the workspace.
Does not have management permissions. | To scale AI usage in the company without seat license cost. **(New Plans: PRO, Business and Enterprise)** |
Legacy Plans - GO, Beginner, Individual and Business Plans
| User Type | Access and Permissions | Notes |
| :--------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------ |
| Owner | Full access to all features: member management, usage history, data, and full control over subscription and billing. | Usually the workspace creator. Has the highest responsibility and control. |
| Manager (Full or Lite) | Can invite/manage members and access execution history and credit consumption for everyone. Cannot change or view subscription/billing information. | Ideal for team leaders who need to manage the team and usage, but not financial aspects. **(Legacy Business Plan)** |
| User (Full) | Standard access to use the platform and create agents. Does not have permissions to monitor history, manage other members, or view team usage data. | Intended for employees who will use Tess AI to create and run daily tasks. **(Legacy Business Plan)** |
| User Lite | Free access to use all AI models, access Chat and use agents already created in the workspace. Cannot create their own agents and has no management permissions. | Role equivalent to "Guest" for older plans. **(Legacy Plans, e.g., Business)** |
| User Lite (Text Only) | A subcategory of User Lite. In this case, users have access only to text AIs (not images, videos, etc.). | Role equivalent to "Guest" for older plans. **(Legacy Plans, e.g., Business)** |
| User Lite (Team Agents Only) | Another subcategory of User Lite. This role allows companies with agents in the workspace to offer controlled access to specific external users. This user will have access exclusively to the workspace team board with agents that have public or workspace visibility. | Role equivalent to "Guest" for older plans. **(Legacy Plans, e.g., Business)** |
### **Advanced Access Control (Teams and Permissions)**
In addition to default roles (Owner, Manager, User/Guest), Tess also allows more granular access control through:
* Custom permissions
* Teams
* Restrictions by team or user
These features are ideal for companies that need to:
* Control which AI models each group can use
* Limit credit consumption by team or user
* Restrict access to connectors or specific features
* Organize users by department (e.g., Marketing, Sales, Operations)
* What you can control
With these settings, it is possible to define:
* Access to AI models (e.g., allow only text models)
* Access to **chat tool groups** (e.g., web search, image generation, integrations) — same governance pattern as models and connectors
* Use of connectors (e.g., Google Drive, Notion, etc.)
* Monthly credit limit
* Specific rules per team or per user
Workspace admins can also **delete custom roles** that are no longer needed (after reassigning members), keeping the permission matrix clean.
> **Screenshot placeholder — tool groups & roles:** Capture (1) team/member restrictions showing **tool group** toggles, and (2) the action to **delete a custom role** in Members/Permissions.
The structure follows this logic:
1. Teams → group users (e.g., “Marketing”)
2. Team policies → define default rules for everyone in that group
3. Individual restrictions → can override team rules for specific cases
> Example:
>
> Marketing Team → access allowed to image models
>
> Specific user → restricted to text only
>
> *In this case, the individual rule takes priority.*
All these settings can be configured within the workspace member management area:
### **Ways to Invite New Members**
You have two options to invite people:
This is the simplest and fastest way to invite multiple people at once, especially for the Guest role.
1. On the Members screen, click the icon to generate a Secret Link.
2. Choose the access level that users invited through this link will have.
3. Activate and copy the generated link to share with your team.
Security Tip: Share this link only in private company channels (such as Slack or internal email). Avoid posting it in public places to prevent unauthorized access.
Ideal for inviting specific people, especially for higher-permission roles such as Manager or User.
1. Click "Add new member".
2. Enter the person's email (or a list of emails separated by commas).
3. Define the member's role.
4. Send the invitation.
**Important:** The invitation sent by email is valid for 3 days (72 hours). After this period, you will need to revoke the expired invitation and send a new one.
### **Managing Members Day to Day**
The "Members" screen is your hub for ongoing team management:
If an employee leaves the team, you can revoke their access immediately by clicking the "X" icon next to their name.
Track each member's credit consumption to understand how resources are being used. To do this, go to the "Usage" tab in your workspace settings menu, where you can filter executions by user and get a detailed view of consumption.
Keep a clear view of paid seats (User) and free seats (Guest / User Lite) to ensure your team is sized intelligently and cost-effectively.
If you have any questions, our team is available at: [support@tess.im](mailto:support@tess.im).
# Assign Members to Teams
Source: https://docs.tess.im/en/members-to-teams
Learn how to move collaborators in your workspace between teams and define the level of authority and role each one will have within their respective team in Tess.
### What is it?
Team assignment is the process of linking a collaborator (registered user) to one or more of the organizational work structures you have created.
This means that the same user can have different operational roles when moving across different divisions of the company (for example, being the technical lead on one project and only a consultative observer on another).
### Where to find it?
Permissions and team associations are centralized on the main screen of your **Members panel**:
1. Access the side menu and click on Members.
2. In the users table, locate the collaborator you want to configure.
3. Their management will initially be in the first column, which is TEAMS.
4. Click the Pencil (Edit) icon located next to the names of the user's current teams.
### How to use
1. To add the user to a new group:
* In the Add to team section, first select which operational role they will have by clicking: Member, Manager, or Viewer.
* In the search field *"Search teams and departments..."*, type to find the desired team.
* Click Add as \[Role] on the right side of the listed team name.
2. At the top of the modal, view Current Teams to see that user's current associations and modify them by opening the selector or removing them with the "X" button.
3. Close the management modal using the "X" button in the top right corner to save the new configuration.
### Practical Difference Between Team Roles
Within a specific team, a member can have 3 levels of permissions:
* **Member (Default):** The user executes tools, chats, agents, and models normally within the rules defined by the operational group.
* **Manager:** Allows the member to act as a team leader, with easier access to team consumption and performance data, and the ability to assign other subordinate users.
* **Viewer:** Limited read-only access to tools and agents shared specifically within that team’s workspace.
**Best practices**
* Keep roles up to date: When a collaborator changes roles internally or is promoted in the real organization, immediately update their role in the Tess admin panel to ensure system security alignment.
* Avoid too many Managers: Assign the Manager role only to actual coordinators and directors of functional areas as part of an internal audit strategy.
By assigning teams and individual roles, you establish corporate responsibility quickly, securely, and flexibly within your Tess workspace!
# Memory Boost
Source: https://docs.tess.im/en/memory-boost
Memory Boost is a feature that helps Tess retrieve relevant parts of the conversation history when the current message's context can no longer hold everything. In practice, it improves the continuity of long chats without requiring you to maintain a high context window all the time.
In Tess, Memory Boost is configured in Preferences. It is an individual setting, done per user, and influences your experience on the platform as a whole.
### **What is it?**
Memory Boost is a support agent that runs in the background to analyze the complete conversation history and bring back only what is most relevant to the current message.
Instead of always sending a larger context to the main model, Tess can use this feature to perform a smart search in the history and complement the response with important excerpts of what has already been said.
In practice, it helps when:
* the conversation is already long
* older parts of the history would no longer fit in the normal context
* you want to save credits without losing continuity
Once configured, the feature works automatically in the background. You don't need to write a specific prompt to "call" Memory Boost.
### **Where to find it?**
To activate the feature:
* In the side menu, click on your user icon, then on Settings and Preferences
* Scroll until you find the Memory Boost option
* Turn on the enable switch and, if you want, click on Change model to choose the model used in the feature:
### **Before using: what you need to know**
Before activating Memory Boost, it's worth understanding some important points:
* **It's a per-user setting:** Each user defines their own preference, and activating the feature does not automatically change the experience of other workspace members. It is a global setting for your experience in Tess.
* **It is not activated per chat individually:** Once turned on, it becomes part of your use on the platform until you turn it off. Memory Boost is complementary to the context.
* **It does not replace the context window:** It helps recover relevant history when the conversation grows.
* **The feature uses a separate model:** This model runs in the background to search the history. Therefore, Memory Boost may generate additional consumption of credits.
* **You don't need to keep the context at maximum all the time:** The system searches the history only for what is useful for that interaction
### **How it works in practice**
Whenever you send a new message, Tess can trigger Memory Boost to analyze the complete conversation history and identify what makes sense to recover at that moment.
Instead of bringing everything back, the system tries to select only the most useful excerpts for the new response.
In practice, the flow is this:
1. you send a message
2. Memory Boost evaluates the history
3. it finds information related to your current request
4. this information helps compose the final response
This is especially useful when the conversation has already gone through many topics; important instructions were given at the beginning of the chat; you need to return to an old topic several messages later.
### **Relationship with Memory Economy Mode**
Memory Boost was designed to work together with Memory Economy Mode. This relationship is important because Memory Economy Mode limits the context per message to reduce cost. In long chats, this can cause old parts of the conversation to stop being considered in the normal flow.
When Memory Boost is active, Tess gains an extra layer of context recovery. Instead of keeping a high window all the time, it searches the history only for what matters for that question.
For example, this combination usually works well with the most economical Memory Economy Mode and Memory Boost activated. This way, you reduce fixed context costs without giving up continuity in longer conversations.
*Not surprisingly, we say it is the Economy Mode’s Best Friend!*
### **When it makes sense to activate**
* maintain long chats for a long time
* work on topics that evolve over several interactions
* usually return to points discussed at the beginning of the conversation
* want to save tokens without losing consistency
* use Tess for analysis, planning, or iterative construction
* ongoing projects
* content production by stages
* work agents with accumulated context
* strategic or consultative conversations
### **When it may not be necessary**
In short chats or very objective tasks, Memory Boost might not make that much of a difference.
For example:
* quick questions
* punctual text adjustments
* independent prompts
* interactions where the history barely matters
In these cases, the feature being off does not hinder, and being active will not negatively impact the result obtained in the conversation.
### **Practical examples**
Example 1: returning to an old instruction
You gave several instructions at the beginning of the chat and, after many messages, you write:
> *“Redo the proposal following that positioning we defined at the beginning.”*\
> \
> In this case, Memory Boost helps retrieve that previous positioning to support the response.
Example 2: long planning chat
Over the course of a long conversation, you build a strategy in stages and want to ask:
> “Now consolidate all of this into a final plan.”\
> Even if the normal context can no longer hold the entire history, Memory Boost can bring relevant parts of what was discussed before.
Example 3: savings with continuity
You keep Memory Economy Mode at a more economical level, but activate Memory Boost to avoid context loss in long conversations.
In this scenario:
* the fixed context cost is lower
* relevant history can still be recovered when necessary\\
### **How to choose the Memory Boost model**
Memory Boost allows you to choose which model will be used to search the history. In practice, this step tends to work well with lighter models, because:
* the work is focused on recovering context
* it is not always necessary to use a more expensive model
* this helps keep the cost under control
In general, the recommendation is to start with a light model and only test something more robust if there is a clear reason for it.
**Best practices**
* Activate Memory Boost mainly in long chats
* Combine the feature with Memory Economy Mode to balance cost and continuity
* Prefer lighter models for this function
* Review usage if you notice a cost increase without practical gain
* Use the feature when the history really matters for the quality of the response
* Guide teams and users not to confuse Memory Boost with "infinite memory"
### **Common mistakes**
1. Activating the feature without necessity: In quick and independent tasks, the gain may be small and the extra cost may not pay off.
2. Using a heavy model in the Boost without necessity: Since the feature runs in the background, choosing a more expensive model can increase the cost without bringing a proportional benefit.
3. Thinking that Memory Boost completely replaces context. It helps recover relevant parts of the history, but does not eliminate the importance of a proper context configuration.
4. Expecting it to recover everything all the time: The goal of the feature is to search for what seems most relevant to the current interaction, not to fully reinject the entire previous conversation.
5. Confusing the feature with a per-chat setting
### **Important notes**
* The feature broadly influences your experience in Tess, not just in an isolated chat
* It uses a separate model to analyze the history, this may generate additional consumption of credits
* The main gain of the feature appears in longer chats
* When combined with Memory Economy Mode, it helps maintain savings without losing as much context
Memory Boost is the ideal feature for those who need to maintain continuity in long conversations but do not want to depend on a consistently high context window.
When used correctly, it improves history recovery, reduces the need for high fixed context, and helps make the use of Tess more efficient on a daily basis.
# Monetization
Source: https://docs.tess.im/en/monetization
Tess offers a complete dashboard so you can closely track the performance of your monetization strategies. Knowing how and where to view your earnings is essential to understand your performance and plan your next steps.
### **Accessing your Monetization Dashboard**
To view your financial information on the platform, the path is simple and quick.
1. Click on your user icon
2. Click on settings
3. Locate Monetization in the Workspace area\\
### **Understanding your Revenue Sources**
When accessing the monetization area, you will find a detailed dashboard with your earnings organized by category:
* **Subscriptions:** Revenue generated from users who subscribe to your Workspace.
* **Agent Sales**: Earnings from the direct sale of your agents.
* **Executions (runs):** Accumulated value from the executions of your agents by other users.
Tess offers a complete dashboard so you can closely track the performance of your monetization strategies. Knowing how and where to view your earnings is essential to understand your performance and plan your next steps.
This dashboard provides a clear and consolidated view of your performance, allowing you to identify which strategies are delivering the best results.
### **Withdrawal Information**
To ensure the security and convenience of our creators, we have established some guidelines for withdrawing earnings.
Withdrawal of funds will be available as soon as you reach a minimum balance of \$1,000.00 (one thousand dollars).
All monetization payments are processed exclusively via PayPal.
Monitoring your earnings regularly not only helps validate your strategies but also helps you plan when you will be able to make your next withdrawal.
If you have any questions, simply contact our support team via email: [support@tess.im](mailto:support@tess.im).
# Integration with n8n
Source: https://docs.tess.im/en/n8n
### **What is n8n?**
n8n is an open-source automation platform that allows you to create custom workflows by connecting different services and APIs. With its flexibility, n8n is ideal for companies looking for tailored automation solutions.
### **Benefits of integrating Tess with n8n**
* Create advanced and custom automations with Tess and other services.
* Easily integrate with APIs and internal systems.
* Reduce manual tasks and increase productivity.
* Leverage the power of open source to adapt integrations as needed.
### **Step-by-Step: Triggering a Tess AI Agent from n8n**
Want to connect n8n with Tess AI? Here's a quick and friendly guide to get you started!
Open n8n and start a new workflow. Each step (node) represents an action or service.
Search for "HTTP Request" in the node panel and add it to your workflow. This node will send a message to your Tess AI agent.
* **URL:** Use `https://api.tess.ai/agents/{agent_id}/execute` (replace `{agent_id}` with your agent's ID, found in the Tess AI platform URL).
* **Method:** Set to `POST`.
* **Headers:** Add `Authorization: Bearer {your_token}` (generate your API token in Tess AI under "API Tokens").
* **Body:** Set to `JSON` and include the message you want to send, e.g.:
```json theme={null}
{
"temperature": "1",
"model": "tess-5",
"messages": [
{ "role": "user", "content": "Hello, how can you help me today?" }
],
"tools": "no-tools",
"wait_execution": true,
"file_ids": [123, 321]
}
```
(You can use n8n expressions to insert dynamic values from previous nodes, like WhatsApp messages.)
Make sure to include the parameter "wait\_execution": true in your request body. This tells Tess AI to wait for the agent's response before moving on, so you can use the reply in the next steps.
Save and run your workflow. Check the output of the HTTP node to see the agent's response. If something's off, double-check your token, agent ID, and JSON formatting.
Want to reply to a user (e.g., on WhatsApp)? Add another node after the HTTP Request to send the agent's answer back.
**Tips:**
* Keep your API token safe—never share it publicly!
* You can remove advanced parameters from the request if they're already set up in your agent.
* Always validate user input before sending it to the agent.
As of **2026-09-01**, Tess API requests must include the `x-workspace-id` header. See [API Overview](/en/api-overview).
# Preferences
Source: https://docs.tess.im/en/preferences
The Preferences section centralizes the settings for personalizing your experience on Tess. Here, you control everything from the interface language and visual theme to advanced settings for chat behavior, memory, subtasks, and file search — all in one place.
### **Where to find it**
1. Log in to your Tess account
2. Click on your profile icon in the bottom-left corner
3. Select "Settings"
4. Click "Preferences"
### **Available settings**
Currently, the Tess platform is available in Portuguese, English, and Spanish. Select the desired language so that all menus and interface texts are translated.
Choose the platform’s visual theme:
| Option | Description |
| :----- | :----------------------------------------------------------------------- |
| Light | White background — default theme |
| Dark | Dark background, ideal for low-light environments |
| System | Automatically adopts the theme configured in your operating system |
Defines which agent is loaded by default when opening the main Tess AI chat.
* By default, the selected agent is Default (Tess general agent)
* You can switch to any of your own agents created on the platform
* Useful for those who always work with a specialized agent and want to access it directly when opening the platform, without needing to navigate to it manually
Usage example: If you have an agent configured for customer support or data analysis, you can set it as Home Agent and start each session with the right context.
Settings that control the behavior of the chat and Tools.
1. **Operations** Defines the maximum number of operations (requests) that Tools can execute to generate a single response in the chat. Maximum value: 25 operations
* Higher numbers allow more elaborate, multi-step tasks
* Lower numbers limit the scope of actions and reduce resource consumption
This limit applies individually per response, not to the conversation as a whole.
2. **Maximum Subtasks per Prompt** Controls how many subtasks the AI can create internally when processing a single prompt. (Learn more in the article: Link)
3. **Memory Saving Mode** Optimizes memory usage during conversations, reducing context consumption. (Learn more in the article: Link)
4. **Memory Boost** Expands the AI’s context retention capacity during the conversation. (Learn more in the article: Link)
These settings control how Tess processes and searches for information within files attached to conversations. They are technical chunking parameters — the way the file content is divided into pieces for analysis.
Experimental feature: these options are still in testing and may change.
1. **Chunk Size (Fragment Size)**
Defines how much of the file is analyzed at each step when answering a question.
| Value | Behavior |
| :------------------------------------- | :------------------------------------------------------------------------------------ |
| 512 characters *(More precise)* | Smaller fragments — better for finding specific details and exact answers |
| 1024 characters *(Default)* | Balance between precision and context |
| 2048 characters *(More Context)* | Larger fragments — better for understanding the overall picture of the document |
**When to use each extreme:**
* Use lower values when you need precise answers about specific excerpts (e.g.: finding a clause in a contract)
* Use higher values when the question requires understanding the broad context of the document (e.g.: summarizing the central idea of a report)
2. **Chunk Overlap (Overlap Between Fragments)**
Defines how much content each fragment shares with the next fragment.
| Value | Behavior |
| :------------------------------------ | :------------------------------------------------------------------------------------ |
| 0 characters *(Less Overlap)* | No overlap — lighter search, with no repetition |
| 128 characters *(Default)* | Moderate overlap — recommended balance |
| 960 characters *(More Overlap)* | High overlap — better when an idea extends across several parts of the document |
**When to adjust:**
* More overlap: when answers seem "cut off" or lose context between paragraphs
* Less overlap: when answers repeat the same information too much
**Best practices**
* Chunk Size + Chunk Overlap go together: try increasing the overlap if you increase the chunk size, to prevent important information from ending up at the "edges" of fragments without context
* Home Agent: set the initial agent only when you have a consistent workflow. For general use, keep Default
* Operations: if Tools are returning incomplete answers in complex tasks, try increasing this value before reformulating the prompt
### Important notes
* Search Settings settings are experimental and may be changed or removed in future versions
* Changes to preferences are saved automatically and applied immediately
* Chunk Size and Chunk Overlap settings affect only search in attached files — they do not impact responses based on plain text
The Preferences section gives you fine control over how Tess behaves, from appearance to how it processes your files. It is worth exploring each setting — especially Search Settings if you work with documents — to extract more precise results aligned with your workflow.
# Process File
Source: https://docs.tess.im/en/process-file
POST https://api.tess.im/files/{fileId}/process
Process a specific file by its ID.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/files/{fileId}/process' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/files/{fileId}/process',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/files/{fileId}/process"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/files/{fileId}/process",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/files/{fileId}/process"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/files/{fileId}/process", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.PostAsync("https://api.tess.im/files/{fileId}/process", null);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/files/{fileId}/process')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The ID of the file to process. Note that this will consume credits.
### **Response**
```json theme={null}
{
"id": 73325,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:26:27+00:00",
"filename": "endpoints.pdf",
"credits": 20.10060847168,
"status": "completed"
}
```
# Refund
Source: https://docs.tess.im/en/refund
If you're not satisfied with your purchase, you can request cancellation with a full refund within the 7-day guarantee period. This period starts from the day you purchased your first subscription.
### **What you need to know (important)**
\
This refund policy applies only to the first purchase of any plan active at the time of subscription. Subsequent refund requests, on any plan, will be considered fraudulent activity and may result in a ban from the platform.
\
At the moment the refund is processed, your plan will be immediately canceled and you will lose access to Tess.
\
Processing may take up to 30 business days, considering the Tess + bank/card issuer flow.
\
You are eligible if:
* This was your first purchase on any active plan
* Your request is within the 7-day guarantee period
* If needed, you can provide proof of purchase or invoice (order number, receipt, etc.)
### You can request a refund directly through the platform:
1. Go to your Subscription settings
2. Click "Cancel My Plan"
3. If the request meets the rules above, follow the refund flow within Tess and your refund will be automatically approved.
**Important:**
If the guarantee period has passed, the subscription will be scheduled for cancellation at the end of the contracted cycle. This means that after the first 7 days:
* If you purchased the monthly plan, you will have access until the end of the current paid month.
* If you signed up for the annual plan, the remaining installments (if you paid in installments) are due and your access will remain active until the end.
If you have any difficulty with the process, send an email to [support@tess.im](mailto:support@tess.im).
# Remote Support
Source: https://docs.tess.im/en/remote-support
We understand that sometimes questions or specific situations may arise that require deeper analysis. Remote Support was created for these moments. It is a feature that allows our team to access your account securely and temporarily.
When you request it, you grant temporary permission — valid for 72 hours — for one of our specialists to access your account. This allows us to view your settings, interactions, and the exact context of the issue, without you needing to share passwords or credentials. It is a secure, practical, and efficient way for us to provide the help you need.
### **1. When should you request Remote Support?**
* Unexpected behavior: When an agent or feature does not behave as expected.
* Configuration difficulties: If you need help setting up a more complex feature.
* Problem analysis: So our team can deeply investigate an issue or difficulty that was not resolved with general guidance.
### **2. How to request Remote Support (Step by Step)**
Click on your username, located in the bottom left corner of the platform, to open the options menu.
A window will open with fields to be completed.
* Support Team E-mail: Enter the email address of the Tess specialist who is in contact with you.
* Description: Detail the reason for your request. Provide as much information and context as possible, as this will help us understand and resolve your request faster.
After filling in the fields, click the "Request" button.
Done! Our team will receive the notification and access will be granted automatically.
# Individual Restrictions
Source: https://docs.tess.im/en/restrictions
Learn how to create governance exceptions using individual security overrides. Define consumption limits, access to data connectors, or blocks for specific models for a user, regardless of the default policies of the team they belong to.
### What is it?
Restrictions (technically known as *"Per-policy strict overrides"*) are the highest-priority rules in Tess's authorization system. When you apply a restriction at the user level, it replaces and overrides any existing permissions at the team level, ensuring precise control.
### How to configure restrictions?
1. Go to the Members screen.
2. Locate the row of the desired user and click the edit pencil button or the "+" button to create a new restriction.
3. In the User Restrictions modal, you will see the three security variables:
* **Connector access:** Define whether the user can access all connectors (such as Google Drive, Slack, Notion) or select restrictions to hide critical corporate connectors.
* **AI model access:** Define whether they will use only standard basic text models or have restricted authorization.
* **Monthly credit limit:** Configure a specific and precise monthly credit quota only for this user.
4. If, at any point, you want the collaborator to go back to following purely the default rules of the rest of their team, click the Restore team defaults button in the bottom left corner.
5. Click Save to immediately apply the new restrictions.
### How it works under the hood (Inheritance vs Override)
The Tess AI security engine operates under a flexible hybrid default permission model:
* Inherit: Fields that you keep with the system default value (such as "All team models/connectors") will make the user continue passively following whatever is changed in their group's governance.
* Override: As soon as you click and change a specific field in their individual profile, the inheritance link for that field is broken. The individual rule takes absolute security priority over any later modifications to the team.
```text theme={null}
[ General Team Rule: CS ]
Allows use of video AI
│
▼
[ Restriction Applied to User Camy ]
Blocks Video Generation Models
│
▼
Result:
Camy will not access videos,
even while being part of the CS team.
```
**Best practices**
* Use only for Exceptions: Use individual restrictions only in specific cases. If you notice that you are creating the same manual restrictions for multiple isolated collaborators, it is a strong sign that you should create a specific team for this profile.
* Connector Security: Use individual restrictions to limit access to critical external data connections in the workspace for freelance collaborators or temporary third-party service providers.
**WARNING:**
Once the individual credit limit is applied, as soon as the user reaches that barrier in real time, new prompts will be paused in chat until there is an automatic monthly account reset or a manual change to the restriction.
The individual restrictions and overrides tool delivers the highest level of refinement for AI compliance policy and cost governance, ensuring that your workspace is always protected against any unexpected situations.
# Rewards
Source: https://docs.tess.im/en/reward
The Tess AI Rewards Program lets you earn credits by completing simple actions (like following our profiles) and high-impact actions (like reviews on platforms and a video testimonial). These credits go into your wallet and can be used normally in Tess.
**Important:**
*Rewards verification is done manually by our team. To validate correctly, the emails used on the platforms (e.g., G2 and Gartner) must be the same as the one used on your Tess account.*
### **Where to find it (how to access it)?**
Click the user icon in the lower-left corner of Tess and then click Rewards:
You can complete the actions in any order and only complete the ones that make sense for you. Make sure the email is the same before posting reviews on G2 or Gartner—this is the fastest and safest way for the team to validate your reward.
Complete the action and keep clicking the checkmark in Tess AI. Wait for approval. After the manual review, the credits are added to your wallet.
**Available rewards**
* Leave a review on G2: 3,000 credits
* Leave a review on Gartner: 2,000 credits
* Video testimonial: 1,000 credits
* Follow Tess AI on LinkedIn: 500 credits
* Follow Tess AI on Instagram: 500 credits
* Follow Rica on LinkedIn: 500 credits
* Follow Rica on Instagram: 500 credits
**Maximum Earnings**
You can earn up to 8,000 credits (equivalent to \$42.55) by completing all available actions.
* Different emails between Tess and the platform (main cause)
* Review not published (e.g., left as a draft)
* Attempting to earn credits by repeating the same action
* Signs of abuse/fraud (may lead to loss of the reward and account measures)
Send an email to our support team at [support@tess.im](mailto:support@tess.im), and attach proof for validation:
* confirmation of your Tess email
* link to your profile/review (when a public link exists)
* screenshot showing the action completed
* for video: file link or the format indicated on the page itself
As soon as the reward is approved, the balance appears in your Wallet and can be used normally!
# Rollback Agent Version
Source: https://docs.tess.im/en/rollback-agent-version
POST https://api.tess.im/agents/{id}/versions/{version_number}/rollback
Restores a specific agent version by creating a new version whose snapshot matches the target. The version history is preserved — no versions are deleted. The rollback is recorded as an audit trail entry. Requires the `agent:version:read` permission.
Attempting to roll back to the currently active version returns a `422` error.
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/agents/8794/versions/2/rollback' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'post',
url: 'https://api.tess.im/agents/8794/versions/2/rollback',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/agents/8794/versions/2/rollback"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.post(url, headers=headers)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/agents/8794/versions/2/rollback",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/agents/8794/versions/2/rollback"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.POST(HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/agents/8794/versions/2/rollback", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.PostAsync(
"https://api.tess.im/agents/8794/versions/2/rollback",
null
);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/agents/8794/versions/2/rollback')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
The agent ID
The version ID to roll back to
### **Response**
```json theme={null}
{
"version": {
"version_id": 10,
"published_at": "2026-04-09T15:00:00+00:00",
"published_by": "user@example.com",
"rollback_from_version": 8,
"snapshot": {
"agent_name": "Customer Support Agent",
"instructions": "You are a helpful customer support assistant.",
"ask_user_questions": [],
"steps": [],
"knowledge_base_files": [],
"type": "chat",
"subtype": "All LLM Models",
"advanced_settings": {
"model": "auto",
"temperature": "1"
},
"visibility": "private"
}
},
"message": "Agent rolled back to version 8. New version 10 is now active."
}
```
### **Response Fields**
| **Field** | **Type** | **Description** |
| :------------------------------ | :--------------- | :----------------------------------------------------------------------------------- |
| message | string | Confirmation message indicating the source version and the new active version |
| version.version\_id | integer | The new version ID created by this rollback |
| version.published\_by | string | Email of the user who performed the rollback |
| version.published\_at | string (ISO8601) | Timestamp when the rollback version was created |
| version.rollback\_from\_version | integer | The `version_id` used as the source for this rollback |
| version.snapshot | object | Complete agent state restored by this rollback (same structure as Get Agent Version) |
### **Error Responses**
#### **Already Active Version (422)**
```json theme={null}
{
"message": "Cannot roll back to the current active version."
}
```
#### **Not Found (404)**
```json theme={null}
{
"message": "Version not found."
}
```
#### **Forbidden (403)**
```json theme={null}
{
"message": "You do not have permission to roll back agent versions."
}
```
# Shared Wallet
Source: https://docs.tess.im/en/shared-wallet
At Tess, we believe that artificial intelligence should be a collaborative tool. That’s why we created a model that allows you to use a single subscription to work with as many people as you want in the same workspace, sharing credits in a single wallet.
### What is the Shared Wallet?
The Shared Wallet is the feature that allows you to invite coworkers, friends, or even family members to your workspace at no extra cost per user. Instead of paying per "seat," your billing is based on the AI credits that the team actually consumes.
Tess works as an AI Marketplace: you have a fixed subscription (annual or monthly) and only pay for credit consumption, without worrying about the number of members. It is a pool of credits that can be shared among countless workspace members.
### How to Invite New Members to Your Workspace
Adding people to your workspace is a simple process.
Log in to your Tess AI account, click on your user menu (bottom left corner), and go to "Settings".
Within the settings, click on the "Members" tab.
Click the "Add new member" button.
Enter the email address of the person you want to invite and send the invitation. Or, if you prefer, send it to more than one person with the same permission level using the secret link.
*The invited person will receive an email with an access link. Upon accepting and creating their account, they will become part of your workspace, using the same credit wallet as you.*
### Understanding Billing and Credit Usage
All credits in your plan, whether from the subscription or standalone packages, go into a single Wallet, which is shared by all workspace members.
With each content generation or interaction with AI, a small amount of credits is deducted from the wallet, depending on the AI model used.
**Important Note about Legacy Plans**
For users on legacy plans (older subscription models such as **GO**, Beginner, Individual, and Business), the per-seat billing system may still apply. If you have one of these plans, check the specific conditions of your subscription or contact our support to migrate to one of the new plans. Even in these cases, we still offer features to invite additional users at no cost.
**Best Practices for Account Management**
> 1. Align expectations: Agree with your workspace members on how credits will be used (for work, study, testing, etc.).
> 2. Track consumption: If you are the account administrator, access the "Wallet" area periodically to understand usage pace and ensure credits meet the team’s needs.
> 3. Learn together: Use the Shared Wallet to encourage people around you to learn about artificial intelligence together with you.
At Tess, we believe AI should be collaborative. With the Shared Wallet, you can bring people around you into the same account, learn together, and take full advantage of the platform without barriers.
If you have any questions, our support team is available to help via email: [support@tess.im](mailto:support@tess.im).
# SSO
Source: https://docs.tess.im/en/sso
At Tess, we offer Single Sign-On (SSO) functionality as part of our Enterprise plan to ensure a robust, centralized, and frictionless authentication process for your team.
### **What is Single Sign-On (SSO)?**
Imagine having a digital master key. Instead of carrying a heavy and complex keychain for every door, you use a single key to access all the environments you need. Single Sign-On (SSO) works in a similar way.
It’s an authentication technology that allows a user to access multiple systems and applications — including Tess — with a single set of credentials (username and password), typically managed by your company’s identity provider (such as Okta, Azure AD, Google Workspace, etc.).
By logging in once to your organization’s system, the user will be automatically authenticated in all integrated applications, without needing to type passwords repeatedly.
It is possible to configure **multiple domains in the same workspace**, allowing different companies or units to share the same environment with centralized authentication.
### **Key Benefits for Your Organization**
Implementing SSO goes beyond convenience, bringing strategic advantages:
1. *Stronger Security:* SSO centralizes access control. This means your company’s security policies (such as multi-factor authentication, password complexity, and expiration rules) are applied consistently. In addition, the process of removing access for a former employee becomes instant and fail-safe.
2. *Simplified Access Experience:* Your employees no longer need to manage dozens of different passwords.
3. *Centralized Management and Auditing:* The IT team gains full visibility and control over who accesses the platform, simplifying permission management and making it easier to generate reports for auditing and compliance purposes.
**Important:**
To meet the security, scale, and governance needs of large organizations, SSO functionality is *available exclusively to Enterprise plan customers.*
### **Multiple Domains**
At Tess, in addition to a single domain, we also support SSO for multiple domains in the same Workspace. With this, the feature becomes even more flexible for complex scenarios and shared environments.
* Useful for:
* Business groups
* Partner operations
* Environments shared between different teams
### **How to Enable SSO in Your Workspace**
SSO setup is a collaborative process, supported by our technical team in partnership with your company’s IT team, ensuring a secure implementation aligned with your internal policies. Typically, the activation process is quite fast, depending on the customer’s responsiveness, taking at most a few days (or less).
If you are an Enterprise customer and would like to enable SSO or have any questions about the process, contact your account manager or write to us at [support@tess.im](mailto:support@tess.im).
**Best practices**
* Clearly define which domains will have access to the workspace when contacting our team
* Avoid allowing generic or public domains
* Ensure that security policies (such as MFA) are active in the IdP
* Periodically review the configured domains and notify our team of any domain changes
# System Status
Source: https://docs.tess.im/en/status
Tess provides a dedicated page where you can monitor in real time the operational status of all our services.
### **What is the System Status page?**
The "System Status" page is a centralized dashboard that informs you about the operational status of the Tess platform and integrated APIs. If any instability or scheduled maintenance occurs, this will be the first place to reflect that information.
### **How to access the Status page?**
> *1. Via direct link*
>
> You can access the dashboard at any time at the following address: [https://status.tess.im/](https://status.tessai.io/).
>
> *2. Through the Tess AI platform*
>
> You can also find the path to the status page within your Tess account. Follow the steps below:
>
> * Go to the "Settings" screen in the left sidebar menu of the platform.
>
> * In the settings menu, select the "Data Control" option.
> * Then click on "System Status".
>
>
### **How to receive status updates?**
For your convenience, you can subscribe to receive automatic notifications about any changes in the status of our services.
On the status page, you will find an option to subscribe ("Subscribe to updates"). You can choose to receive all notifications or only those related to specific platform components that are most relevant to your usage.
**IMPORTANT!**
If the status page indicates that all systems are operational, but you are still experiencing issues, it may be a problem specific to your account or configuration. In that case, do not hesitate to contact us.
If you have any questions, our support team is available to help via email: [support@tess.im.](mailto:suporte@tessai.io)
# Subscription and Payment
Source: https://docs.tess.im/en/subscription
1. **PLANS AND PAYMENTS**
The main questions about our plans.
Currently, we offer the **PRO, Business, and Enterprise** plans. Each plan provides a set of features and a volume of credits suited to different usage profiles. See more at: [https://tess.im/pricing](https://tess.im/pricing)
Some users may still be on **legacy plans** (such as **GO** or older packaging). Those plans are no longer sold as current offers. If you need to migrate, see [https://tess.im/pricing](https://tess.im/pricing) or contact support.
At Tess, transparency is fundamental. Unlike other platforms, you will always know exactly how many credits you have and how much each AI model consumes. Tess operates as a marketplace: we simply pass through the cost of each model (set by its respective provider), with a flat margin.
For each action performed on the platform (and each selected model), credit consumption (or its proxy) is clearly displayed. In chat, you will see the number of credits consumed per 100 input tokens (what you send to the AI) and per 100 output tokens (the AI’s response). For image and video, you will be informed, for example, of the cost to generate each artifact. This allows you to manage your credits diligently, choosing the most appropriate model for each task.
• Diligent Management: Just as you manage your personal finances, it is important to manage your credits on the platform. AI models for image and video, for example, tend to consume more credits than text models. By selecting the right model for the task, you optimize your usage and ensure your credits last longer.
All users can track their credit balance in real time in the AI Wallet by clicking the yellow coin icon in the top right corner of the chat.
No. In all plans, we charge based on usage. We use a shared wallet system, allowing unlimited members to be added to the Workspace. Billing is therefore based on usage, managed through the credit system in Tess!
In other words, you can invite unlimited users at no extra cost: family, coworkers, classmates, etc. Each person gets their own private account with individual usage tracking, but everyone uses a shared pool of credits from the Workspace.
This is the ideal model for teams or study groups to collaborate on projects, as well as for family use (“family account”), noting that Tess offers a Parental Control feature so parents can monitor AI usage by younger users.
Yes. You can add or remove members from your workspace at any time within the Members area.
In the Enterprise plan, you also have Single Sign-On (SSO), which provides greater security for all employees.
Payment is made by credit card, with the option to split the annual amount into up to 12 interest-free installments. For annual plans, we also offer payment via PIX.
In the Enterprise plan, the company can also choose other payment options such as invoice, PIX, and bank transfer.
2. **MANAGING YOUR SUBSCRIPTION**
Keeping control of your subscription is simple and intuitive in Tess.
You can upgrade your plan at any time. Just go to your account settings and click on "Manage Plan." There, you can choose the plan that best suits your needs, and the upgrade will be applied immediately to all members of your account. In this case, billing will be prorated, calculated proportionally considering the end of the current cycle, whether monthly or annual.
As the owner of your company’s workspace, you have full visibility into credit consumption and platform usage. You can export the data to analyze individually who is consuming more or less, as well as monitor Tess activity history, including conversations, image generations, or videos. To do this, go to settings and then the Usage tab.
3. **SUBSCRIPTION CANCELLATION**
We understand that needs can change. That’s why the process to cancel your subscription is simple and straightforward.
To cancel your subscription, go to the "Subscription" area in your account settings and click the "Cancel My Plan" button. A brief question about the reason for cancellation will be asked to help us improve.
When you cancel, your access to the platform will continue until the end of the current billing period. For example, if you subscribed to an annual plan and cancel in the second month, you will still have full access to the tool until the end of the twelfth month. And if you subscribed to the monthly plan, it will also remain active for the remaining days of the contracted month.
Yes, Tess offers a 7-day satisfaction guarantee for new users. During this period, you can test the platform and explore the available features. If you are not satisfied, you can request a full refund automatically within the 7-day period.
## **Support and Contact**
For any other questions related to your subscription that are not covered here, our support team is available. Send an email to [support@tess.im](mailto:support@tess.im).
# Subscription
Source: https://docs.tess.im/en/subscription-page
The "Subscription" section is your portal for all matters related to your plan on Tess AI. From there, you can manage your plan, view your history, and make other billing settings.
### **How to access your Subscription information**
Log in to your Tess AI account and then click on your profile icon, located in the lower-left corner of the screen. In the menu that opens, select the "Configurações" option.
Locate the option: "Assinatura".
### **Managing your Subscription**
By clicking "Manage Subscription", you'll be redirected to our secure payment portal. There, you'll have access to all the tools to manage your plan, including:
* Change the current plan (upgrade or downgrade).
* View and download invoices and payment history.
* Enable automatic credit top-up
* Purchase individual credit packages
* Cancel your subscription.
### **Exploring the Subscription Screen Options**
The screen is divided into buttons that allow quick actions on your account. Let's understand each one of them:
By clicking here, you'll be redirected to a screen where you can track the main details of your subscription:
Here you'll be redirected to the plans tab to choose your migration. (See more details in the Upgrade and Downgrade documentation)
If your plan's credits are running out before the renewal date, you can use this option to make a one-time purchase and top up your wallet. It's the fastest way to ensure continued use of the platform without interruptions.
This option is only available for the old Business plan, where billing was done per user and the Workspace owner could add paid users to the account.
If you want to cancel your subscription and stop using Tess, this button will allow you to schedule the cancellation at the end of the contracted cycle.
That means if you purchase the monthly plan and use it for 10 days, you'll still have 20 days remaining. If you purchase the annual plan and cancel in the fourth month, you'll still have Tess available for the next 8 months.
To ensure your team never runs out of credits and has the service interrupted, you can enable automatic top-up (Pay as you Go). This feature monitors your balance and automatically recharges credits when the balance reaches a minimum amount defined by you.
To set it up, click "Enable automatic top-up" and define the rules:
* When the credit balance falls below: Set the minimum number of credits that will trigger the top-up.
* Amount of credits to add: Choose the number of credits (or the corresponding monetary value) that will be purchased with each top-up.
After adjusting the rules, save the settings to activate the service.
# Support Contact
Source: https://docs.tess.im/en/support-contact
**Support channels available from our team**
\
This is the most commonly used channel by users. Support is handled by a highly trained AI assistant, available 24 hours a day, 7 days a week, in any language.
It is prepared to answer questions about using the Tess platform, agent configuration, integrations, plans and features, common usage issues, and other topics.
How to access the Chat?
Go into Tess, in the bottom left corner of the screen, open the chat. Click on “Talk to Support”, send your question in natural language, and wait for the AI assistance!
\
This is the channel for cases that require more detailed human analysis: investigations, complex questions, account context, usage history, etc. The address is: [support@tess.im](mailto:support@tess.im) (BR) and [support@tess.im](mailto:support@tess.im) (International).
Support is available on business days, from 9:30 AM to 6:00 PM (Brasília time). Each plan has its own response SLA, but in general our team is very agile and responds to all users within a few hours or up to 1 business day.
**What to include in the email?**
To speed up your request, include whenever possible:
* Clear description of the question or issue
* Screenshots or videos showing what is happening
* Workspace name and, if applicable, the agent involved
* Step-by-step instructions to reproduce the error
* Approximate date and time when the issue occurred
\
This is the direct channel with the sales team, for conversations about Tess demos, pricing and plan information for hiring, commercial proposals, or other sales-related questions.
Available at: [sales@tess.im](mailto:sales@tess.im) and operates during the same business hours as support: weekdays, from 9:30 AM to 6:00 PM (Brasília time).
Need help? Don’t hesitate to contact us through the channel that makes the most sense for you.
# Team Board
Source: https://docs.tess.im/en/team
Imagine having a profile page dedicated to showcasing the best creations from your workspace, sharing your knowledge, and building a brand within the Tess AI community. This place exists and is called the Team Panel.
This panel is your public showcase, a space where other users can discover, follow, and interact with the agents and content you choose to share.
*(Example: Tess AI CS team panel)*
### **Navigating the Team Panel**
Your panel is composed of a visual identity and engagement metrics, followed by tabs that organize your public content.
At the top of your panel, users see the essential information that defines your team:
* Workspace Logo and Name: The visual identity and name you defined in the settings.
* Title and Cover Image: An impactful phrase and an image that represent your team’s mission.
* Executions: The total number of times your workspace’s public agents have been executed by the entire Tess community.
* Followers: How many Tess AI users have chosen to follow your workspace to keep up with your updates.
* Following: The number of other workspaces your team follows.
* Likes: The total number of "likes" your public agents and images have received.
The content of your panel is organized into three main sections:
* Tab "IAs":\
This is your agent gallery. All agents that you or your team created and set as "Workspace" will appear here. It is the best way to share created agents with your entire team and with the Tess AI community, if you want to monetize your workspace.
* Tab "Feed":\
Works like a visual portfolio. All images generated by members of your workspace and shared publicly are displayed here.
* Tab "About":\
This is where you tell your story. This section displays your workspace bio, a description of your mission, and links to your social media or website that you added in the settings.
### **How to Set Up Your Panel**
Customizing your panel is done directly in your workspace settings.
Access your Team Panel and click the "Workspace Settings" button.
**Important**
*Only workspace Owners and Managers have permission to perform this action.*
# Update Memory Collection
Source: https://docs.tess.im/en/update-collection
PUT https://api.tess.im/memory-collections/{collectionId}
Updates an existing memory collection.
### **Code Examples**
```http cURL theme={null}
curl --request PUT \
--url 'https://api.tess.im/memory-collections/{collectionId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"name": "Updated Collection Name"
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
name: "Updated Collection Name"
};
const config = {
method: 'put',
url: 'https://api.tess.im/memory-collections/{collectionId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: data
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/memory-collections/{collectionId}"
payload = {
"name": "Updated Collection Name"
}
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
response = requests.put(url, json=payload, headers=headers)
print(response.json())
```
```php PHP theme={null}
"Updated Collection Name"
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/memory-collections/{collectionId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String requestBody = "{\"name\":\"Updated Collection Name\"}";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memory-collections/{collectionId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.PUT(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"name": "Updated Collection Name"
}
jsonData, err := json.Marshal(data)
if err != nil {
fmt.Println(err)
return
}
client := &http.Client{}
req, err := http.NewRequest("PUT", "https://api.tess.im/memory-collections/{collectionId}", bytes.NewBuffer(jsonData))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var requestData = new
{
name = "Updated Collection Name"
};
var content = new StringContent(
System.Text.Json.JsonSerializer.Serialize(requestData),
Encoding.UTF8,
"application/json"
);
try
{
var response = await client.PutAsync("https://api.tess.im/memory-collections/{collectionId}", content);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memory-collections/{collectionId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
name: 'Updated Collection Name'
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
Collection ID
### **Request Body**
Name of the collection
### **Response**
```json theme={null}
{
"message": "Collection updated successfully",
"collection": {
"id": 2,
"user_id": 1,
"name": "string"
}
}
```
### **Error Responses**
#### **Collection not found (404)**
```json theme={null}
{
"message": "Collection not found"
}
```
# Update Memory
Source: https://docs.tess.im/en/update-memory
PATCH https://api.tess.im/memories/{memoryId}
Updates an existing memory.
### **Code Examples**
```http cURL theme={null}
curl --request PATCH \
--url 'https://api.tess.im/memories/{memoryId}' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"memory": "Updated memory content",
"collection_id": 1
}'
```
```json Node.js theme={null}
const axios = require('axios');
const data = {
memory: "Updated memory content",
collection_id: 1
};
const config = {
method: 'patch',
url: 'https://api.tess.im/memories/{memoryId}',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Content-Type': 'application/json'
},
data: data
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
import json
url = "https://api.tess.im/memories/{memoryId}"
payload = {
"memory": "Updated memory content",
"collection_id": 1
}
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Content-Type": "application/json"
}
response = requests.patch(url, headers=headers, json=payload)
print(response.json())
```
```php PHP theme={null}
"Updated memory content",
"collection_id" => 1
];
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/memories/{memoryId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode($data),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: application/json"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String jsonBody = "{\"memory\":\"Updated memory content\",\"collection_id\":1}";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/memories/{memoryId}"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString(jsonBody))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]interface{}{
"memory": "Updated memory content",
"collection_id": 1,
}
jsonData, _ := json.Marshal(data)
client := &http.Client{}
req, err := http.NewRequest("PATCH", "https://api.tess.im/memories/{memoryId}", bytes.NewBuffer(jsonData))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
var data = @"{
""memory"": ""Updated memory content"",
""collection_id"": 1
}";
var content = new StringContent(data, Encoding.UTF8, "application/json");
try
{
var response = await client.PatchAsync("https://api.tess.im/memories/{memoryId}", content);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/memories/{memoryId}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = {
memory: 'Updated memory content',
collection_id: 1
}.to_json
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Path Parameters**
ID of the memory to update
### **Request Body**
New memory content
Collection ID to associate the memory
```json theme={null}
{
"memory": "Updated memory content",
"collection_id": 1
}
```
### **Response**
```json theme={null}
{
"message": "Memory updated successfully!",
"memory": {
"id": 10,
"user_id": 1,
"memory": "Updated memory content",
"credits": 0,
"collection_id": 1,
"collection": {
"id": 1,
"user_id": 1,
"name": "default"
}
}
}
```
### **Response Codes**
| **Code** | **Description** |
| :------- | :--------------- |
| 200 | Success |
| 404 | Memory not found |
| 500 | Server error |
# Upgrade and Downgrade
Source: https://docs.tess.im/en/upgrade-downgrade
At Tess AI, we want you to have full control and flexibility over your subscription. That’s why we implemented a self-service feature for plan upgrades and downgrades.
We’ll explain the process and which rules apply to each case.
### **Understanding the Concepts: Upgrade vs. Downgrade**
It’s essential to understand the difference in when each change takes effect:
* The change is immediate.
As soon as you confirm the change, the new benefits and limits of your higher plan are already available to use.
* The change is scheduled.
The new plan, naturally being lower than the current one, will only take effect at the end of your current billing cycle.
If your plan is monthly, the downgrade will happen on the date of the next monthly renewal. If it’s annual, the downgrade will happen on the date of the next annual renewal. Until the renewal date, you will continue enjoying all the benefits of your current plan that has already been paid for.
### **Rules by Payment Method**
The rules for changing plans vary depending on your subscription’s payment method.
This is the most flexible scenario compared to the annual option. If your subscription is paid monthly via credit card, you can:
* Upgrade to any plan (monthly or annual) at any time.
* Downgrade to any plan (monthly or annual) at any time. Remembering that it will activate at the end of the current cycle.
For the annual plan (installments or not) there are specific rules:
* Upgrade: You can do it at any time, but only to other annual plans.
* Downgrade: This option is not available in self-service for this payment model.
* Billing Period Migration: It is not possible to change from an annual plan to a monthly plan.
Important Note:
In exception situations, downgrades for installment plans can be reviewed and processed by our support team. If you need it, please contact our team by email: [support@tess.im](mailto:support@tess.im).
### **Where to Change Your Plan**
You can start the plan change process simply and quickly in two areas of the platform:
1. By accessing the Upgrade option after clicking your user icon
2. Or by clicking settings, subscription, and finally the "Update Plan" button
Both paths will take you to the same page, where you can view all available plans and make your choice autonomously.
# Upload File
Source: https://docs.tess.im/en/upload-file
api-reference/upload-file.openapi.json POST /files
Upload a new file to the system and optionally process it.
**Maximum 32 MB per file on this endpoint.** This single-shot `POST /files` endpoint sends the file body through the API server, which has a hard 32 MB inbound request size limit. Files larger than 32 MB are rejected before they reach the application layer.
For files larger than 32 MB, use the [v2 signed-upload flow](/en/upload-file-v2) instead. It uploads the file body directly from your client to Google Cloud Storage (the API server is not in the data path) and supports files up to 200 MB.
### **Supported files**
| **Label** | **File Pattern(s)** |
| :---------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Text | `*.txt` |
| Word | `*.{doc,docx}` |
| Spreadsheet | `*.csv` |
| PDF | `*.pdf` |
| Excel | `*.xls`,`*.xlsx` |
| Power Point | `*.{ppt,pptx}` |
| Image | `*.{jpg,jpeg,png,gif,bmp,svg,tiff,webp}` |
| Video | `*.{mp4,avi,mov,mkv,wmv,flv}` |
| Audio | `*.{mp3,wav,aac,ogg,flac,m4a}` |
| Code | `*.bas`, `*.bat`, `*.xml`, `*.css`, `*.dart`, `*.{html,htm}`, `*.inc`, `*.js`, `*.json`, `*.kt`, `*.lua`, `*.pas`, `*.php`, `*.pl`, `*.ps1`, `*.py`, `*.r`, `*.sh`, `*.vsd`, `*.sql`, `*.swift`, `*.ts`, `*.vb`, `*.vba`, `*.{yml,yaml}`, `*.md` |
### **Limits**
* Maximum file size per upload on this endpoint: **32 MB** (platform inbound HTTP request size limit). For files up to 200 MB use the [v2 signed-upload flow](/en/upload-file-v2).
* This endpoint accepts one file per request (use multiple requests for multiple files).
* File storage limit: 30 files
* Some features have different limits:
* Chat attachments: up to 200 MB per file via the v2 signed-upload flow; up to 5 files per send
* Audio transcription: up to 10 MB per file
### **Code Examples**
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/files' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: multipart/form-data' \
--form 'file=@/path/to/file' \
--form 'process=false'
```
```json Node.js theme={null}
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const form = new FormData();
form.append('file', fs.createReadStream('/path/to/file'));
form.append('process', 'false');
const config = {
method: 'post',
url: 'https://api.tess.im/files',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
...form.getHeaders()
},
data: form
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/files"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
files = {
'file': open('/path/to/file', 'rb')
}
data = {
'process': 'false'
}
response = requests.post(url, headers=headers, files=files, data=data)
print(response.json())
```
```php PHP theme={null}
"https://api.tess.im/files",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => [
'file' => $file,
'process' => 'false'
],
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Content-Type: multipart/form-data"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.io.File;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
String boundary = "---boundary" + System.currentTimeMillis();
File file = new File("/path/to/file");
HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/files"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Content-Type", "multipart/form-data;boundary=" + boundary)
.POST(HttpRequest.BodyPublishers.ofFile(file.toPath()))
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"mime/multipart"
"net/http"
"os"
)
func main() {
file, err := os.Open("/path/to/file")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("file", "filename")
if err != nil {
fmt.Println(err)
return
}
io.Copy(part, file)
writer.WriteField("process", "false")
writer.Close()
client := &http.Client{}
req, err := http.NewRequest("POST", "https://api.tess.im/files", body)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Content-Type", writer.FormDataContentType())
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(respBody))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
using (var formData = new MultipartFormDataContent())
{
var fileContent = new ByteArrayContent(File.ReadAllBytes("/path/to/file"));
formData.Add(fileContent, "file", "filename");
formData.Add(new StringContent("false"), "process");
try
{
var response = await client.PostAsync("https://api.tess.im/files", formData);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch(HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ",e.Message);
}
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'
uri = URI('https://api.tess.im/files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
form_data = [
['file', File.open('/path/to/file')],
['process', 'false']
]
request.set_form form_data, 'multipart/form-data'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Response**
```json theme={null}
{
"id": 73325,
"object": "file",
"bytes": 35504128,
"created_at": "2025-01-05T22:26:27+00:00",
"filename": "endpoints.pdf",
"credits": 0,
"status": "waiting"
}
```
# Upload Large File
Source: https://docs.tess.im/en/upload-file-v2
api-reference/upload-file-v2-sign.openapi.json POST /v2/files/sign
Upload files up to 200 MB. The client uploads the file body directly to Google Cloud Storage with a short-lived signed PUT URL, then registers the upload with the API.
Use this endpoint whenever the file is larger than 32 MB. For files up to 32 MB, the single-shot [POST /files](/en/upload-file) endpoint is simpler and still supported.
### How it works
The file body is uploaded **directly from the client to Google Cloud Storage** using a short-lived V4-signed PUT URL — the bytes never pass through the API server, which lets the endpoint accept files up to 200 MB.
A single upload is three calls from the client:
1. **`POST /v2/files/sign`** — the API mints a signed GCS PUT URL valid for \~15 minutes and returns the headers the client must echo on the PUT.
2. **`PUT`** the file body directly to the returned `uploadUrl`. The PUT carries **exactly** the headers from `requiredHeaders` — no more, no less — they are bound into the V4 signature, so a missing, extra, or different header makes GCS reject the PUT with `403`.
3. **`POST /v2/files/register`** — the API verifies the uploaded object's size against what you declared at `/sign`, moves it server-side from the temporary staging area to its final location, deduplicates by content hash, and returns the standard `FileDTO` (same shape as [POST /files](/en/upload-file)).
### Step 2 — direct PUT to Google Cloud Storage
Send exactly the headers returned in `requiredHeaders` (currently `Content-Type` and `x-goog-if-generation-match`):
```http cURL theme={null}
curl --request PUT \
--url 'PASTE_uploadUrl_HERE' \
--header 'Content-Type: application/pdf' \
--header 'x-goog-if-generation-match: 0' \
--upload-file './report.pdf'
```
GCS returns `200` on success. The `x-goog-if-generation-match: 0` header makes the PUT **create-only** — replays return `412 Precondition Failed`.
### Step 3 — register the upload
After the PUT succeeds, finalize the upload. The declared size does not need to be sent again — the server remembers the `size` you declared at `/sign` (for \~16 minutes) and compares it against the actual uploaded object:
```http cURL theme={null}
curl --request POST \
--url 'https://api.tess.im/v2/files/register' \
--header 'Authorization: Bearer ' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Content-Type: application/json' \
--data '{
"object_path": "",
"filename": "report.pdf",
"content_type": "application/pdf",
"process": false
}'
```
Returns `201` with the standard `FileDTO`. If a file with identical content already exists in the workspace, the API returns `200` with the existing file's `FileDTO` instead of creating a duplicate. The optional `process` field works exactly like on [POST /files](/en/upload-file).
### Supported files
Same as [POST /files](/en/upload-file) — Text, Word, Spreadsheet, PDF, Excel, PowerPoint, Image, Video, Audio, and 30+ code extensions.
### Limits
* Maximum file size per upload: **200 MB**
* One file per flow (run the three steps again for additional files)
* Storage limit: 30 files
### Errors
| Status | Meaning |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `400` | `/register` validation failed (missing field or malformed `object_path`) |
| `401` | Missing or invalid Bearer token |
| `403` | Caller lacks API permission for the target workspace — or, on the GCS `PUT`, the headers do not match `requiredHeaders` |
| `404` | Upload session expired (\~15-minute window) or unknown, or the object was never uploaded — start again at `/sign` |
| `412` | On the GCS `PUT`: the object already exists (the signed URL is create-only) |
| `415` | Unsupported `content_type` at `/register` |
| `422` | `/sign` validation failed (missing field or `size` > 200 MB) — or the uploaded object is larger than the size declared at `/sign` (the object is deleted) |
| `429` | Throttled |
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
# Usage Monitoring
Source: https://docs.tess.im/en/usage
Having complete visibility over how the members of your Workspace use Tess AI can be essential for security, governance, cost control, and the optimization of your processes.
For families, Usage control enables Parental Control, meaning parents who are the Owners of Workspaces can closely monitor how their children are using AI. On the other hand, managers can track the engagement and evolution of their team members.
The "Usage" screen was created exactly for these situations, offering a detailed history of interactions with AI in your workspace.
### **How to access the Usage screen**
The screen presents a complete record of every time an AI model was triggered. You can filter and analyze this information to gain valuable insights.
### **Using the Filters**
At the top of the screen, you will find filters to refine your search:
1. **Type:** Allows you to filter by type of interaction, such as chat, Images, Codes, among others.\\
2. **User**: Select a specific member of the Workspace to view only their activities.
3. **Period**: Choose a time range for the analysis, with quick options for the last 1, 7, or 30 days.
**Note**
*When exporting CSV, it is possible to customize the analysis period, expanding or specifying ranges different from the previous options.*
### **Understanding the table data**
Each row in the table represents a single AI execution and is detailed in the following columns:
The name of the AI Agent that was used in the interaction or Tess Standard Chat (identified as Tess 6).
The type of execution (e.g.: Chat, Video, Image, etc).
From where the call was made. It will generally be "Platform" (indicating direct use within Tess) or "API" (if the call came from an external system).
The email of the team member who performed the action.
The exact day and time when the interaction occurred.
The amount of credits that was consumed by that specific interaction. This column is fundamental for tracking costs.
A shortcut that takes you directly to the conversation or the record of that specific interaction, allowing for a quick and contextualized audit. Here, Owners and Managers will be able to access the logs of conversations and executions.
### **Exporting Data for Analysis**
For deeper analysis, creation of custom reports, or long-term storage, you can export the data.
Click the "Export CSV" button in the upper right corner. This will download a file in CSV format (compatible with Excel, Google Sheets, and other spreadsheet tools) containing all the data that matches the filters selected at the time of export.
Next, select the period for which you want to pull the data:
Immediately after, upon exporting the CSV, the document will be sent to your email.
### **Why is this screen important?**
Monitor the use by your children or your team, in order to prevent incompatible or dangerous use.
Monitor exactly which interactions and users are consuming the most credits.
Keep a clear record of all activities performed, ensuring security and compliance.
Identify which agents are the most popular and which team members are using the platform the most.
### Usage history and audit
Besides conversations, the history also works as a control tool:
Administrators can view:
* Executions coming from Public Links
* Executions via Embed
* Interactions made by anonymous users
With this, it is possible to understand the real usage of public content, monitor external access, and, naturally, have more transparency over credit consumption.
These executions appear with a clear source identification such as:
* "Anonymous user (Public Link)"
* "Anonymous user (Embed)"
# Integration with WhatsApp via Make
Source: https://docs.tess.im/en/whatsapp-make
### **What is WhatsApp?**
WhatsApp is one of the most popular messaging apps in the world, used by billions of people for personal and professional communication. It allows you to send messages, files, images, and much more quickly and securely.
### **Benefits of integrating Tess with WhatsApp via Make**
* Send notifications and automated messages to WhatsApp using the Make integration.
* Improve customer service and communication with users.
* Automate responses and interaction flows by connecting Tess with WhatsApp through Make.
* Increase engagement and efficiency in customer contact.
When calling the Tess API from this integration, include `x-workspace-id` (**required as of 2026-09-01**). See [API Overview](/en/api-overview).
# Workspace
Source: https://docs.tess.im/en/workspace
When you create your account on Tess, the next step is to customize your Workspace. This environment is your work panel (whether individual or collective), and setting it up correctly is essential to create an identity for your team and facilitate collaboration.
### **What is the Workspace?**
Think of the Workspace as the main profile of your account. It is the page that represents your team or your company within Tess. This is where you define the name, image, and information that all members and visitors will see.
### **Accessing Workspace Settings**
There are two simple paths to reach the settings screen:
* Access your team's main panel.
* Click on the "Workspace Settings" option.
* Click on your profile icon in the bottom-left corner.
* Select the "Settings" option and locate the Workspace.
Both paths will take you to the same customization screen:
### **Customizing Your Workspace Information**
Now, let's fill in the fields to bring your work environment to life:
The display name of your Workspace. It can be your company name, your team name, or your personal name.
The unique identifier of your profile (e.g.: @your\_company). It will be used in the URL of your public profile.
The main image that represents the account. Ideal for using your company logo or a professional photo.
A short, impactful phrase that appears just below the name, in the header of your profile.
The header image that sits at the top of your Workspace, functioning as a banner.
A space for more detailed information. The text entered here will be visible on the "About" tab of your profile.
You can add links to your social media profiles or your company's profiles. These links will appear on your profile and redirect anyone who clicks on them to the respective pages, centralizing your brand's contact points.
### Final Step: Save Your Changes!
After filling in and reviewing all the information, click the "Save" button. This is the most important step to ensure all your customizations are applied.
Your Workspace is now set up with your team's visual identity and information. Remember that you can revisit these settings and edit whatever is necessary at any time, following the same process.
# Workspace usage
Source: https://docs.tess.im/en/workspace-usage
GET https://api.tess.im/workspaces/usage
List agent execution history for a workspace with filters, pagination, and enriched fields.
Your API token must be allowed to **use agents** (`use_agents`), and you must have access to the workspace—the same layers as other agent and file API routes (Sanctum authentication, workspace access check).
### **Code Examples**
```http cURL theme={null}
curl --request GET \
--url 'https://api.tess.im/workspaces/usage?range=7d&page=1&per_page=20' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID' \
--header 'Accept: application/json' \
--header 'x-workspace-id: YOUR_WORKSPACE_ID'
```
```json Node.js theme={null}
const axios = require('axios');
const config = {
method: 'get',
url: 'https://api.tess.im/workspaces/usage',
params: {
range: '7d',
page: 1,
per_page: 20
},
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'x-workspace-id': 'YOUR_WORKSPACE_ID',
'Accept': 'application/json',
'x-workspace-id': 'YOUR_WORKSPACE_ID'
}
};
try {
const response = await axios(config);
console.log(response.data);
} catch (error) {
console.error(error);
}
```
```python Python theme={null}
import requests
url = "https://api.tess.im/workspaces/usage"
params = {
"range": "7d",
"page": 1,
"per_page": 20
}
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"x-workspace-id": "YOUR_WORKSPACE_ID",
"Accept": "application/json",
"x-workspace-id": "YOUR_WORKSPACE_ID"
}
response = requests.get(url, params=params, headers=headers)
print(response.json())
```
```php PHP theme={null}
'7d',
'page' => 1,
'per_page' => 20
]);
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.tess.im/workspaces/usage?" . $query,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer YOUR_API_KEY",
"x-workspace-id: YOUR_WORKSPACE_ID",
"Accept: application/json",
"x-workspace-id: YOUR_WORKSPACE_ID"
]
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "Error: " . $err;
} else {
echo $response;
}
```
```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.tess.im/workspaces/usage?range=7d&page=1&per_page=20"))
.header("Authorization", "Bearer YOUR_API_KEY")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.header("Accept", "application/json")
.header("x-workspace-id", "YOUR_WORKSPACE_ID")
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
```go Go theme={null}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.tess.im/workspaces/usage?range=7d&page=1&per_page=20", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
req.Header.Add("Accept", "application/json")
req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
```
```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
try
{
var response = await client.GetAsync("https://api.tess.im/workspaces/usage?range=7d&page=1&per_page=20");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
catch (HttpRequestException e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
}
}
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
uri = URI('https://api.tess.im/workspaces/usage?range=7d&page=1&per_page=20')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Accept'] = 'application/json'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
response = http.request(request)
puts response.read_body
```
### **Headers**
Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.
### **Query parameters**
Relative window: 1d, 7d, or 30d. Ignored if both start\_date and end\_date are sent. If no date parameters are sent, the effective default is 30d.
Start of a custom range (inclusive). Required with end\_date.
End of a custom range (inclusive). Must be greater than or equal to start\_date. Required with start\_date. The span cannot exceed 90 days; otherwise 422.
Filter by the user who ran the agent. Without workspace permission to read other users' activity, you only see your own executions; filtering by another user's id returns 403.
Agent type filter: all, chat, image, text, voiceover, video, code. all or omitted means no type filter.
Page number. Default 1, minimum 1.
Page size. Default 20, between 1 and 100.
**Date windows**
* With **`start_date` + `end_date`**: the inclusive range is capped at **90 days**.
* With **`range`**: the window is relative to the **end of the current day** (`1d` last 24 hours from that instant; `7d` / `30d` last seven or thirty calendar days from that end).
* If the **`usage_history_min_date`** feature is enabled in app settings, the effective start of the range is not earlier than that date (silent clamp).
**Caching**
* Listings are cached about **60 seconds** per workspace, filters, and page. Identical requests within that window may return the same payload.
### **Response**
```json theme={null}
{
"items": [
{
"id": "183450",
"created_at": "2026-04-07 16:17:09",
"user_id": 16643,
"type": "chat",
"status": "succeeded",
"email": "user@example.com",
"credits": 1.5,
"name": "My personal assistant",
"slug": "9b4994e3-07e9-4163-b5c0-9c4f18945eda-my-personal-assistant",
"output": "This content is only available on Tess",
"root_id": null,
"execution_origin": "Platform",
"source": "current",
"used_model": "gpt-4o-mini",
"execution_mode": "chat",
"tokens": {
"input": 1240,
"output": 320,
"total": 1560
},
"link": "/dashboard/user/ai/chat/ai-chat/9b4994e3-07e9-4163-b5c0-9c4f18945eda-my-personal-assistant?_chat_id=183450"
}
],
"pagination": {
"current_page": 1,
"per_page": 20,
"has_more": false
}
}
```
Pagination uses **`has_more`**: the service requests `per_page + 1` rows; if the extra row exists, **`has_more`** is `true` and only the first **`per_page`** items appear in **`items`**.
### **Item fields**
| **Field** | **Description** |
| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| id | Execution id, or a synthetic id such as `chat-edited-{user_openai_id}` for edited chats. |
| created\_at | Timestamp of the execution. |
| user\_id | User who ran the agent. |
| type | Agent type from the agent definition (for example `chat`, `image`, `text`, `voiceover`, `video`, `code`). |
| status | `succeeded` or `failed` (non-success statuses map to `failed`). |
| email | Email of the executing user. |
| credits | Credits charged; **0** when status is not `succeeded`. |
| name | Agent title. |
| slug | Agent slug. |
| output | For **current** rows: for `image`, `video`, and `voiceover` this is the real output; for other types it is the fixed text **`This content is only available on Tess`**. For **archived**: **`This item was deleted.`** For **edited**: **`This item was edited.`** |
| root\_id | Conversation root for chats, when present. |
| execution\_origin | Taken from execution metadata when available. |
| source | `current`, `archived`, or `edited`. |
| used\_model | Model name when stored (`user_openai.used_model`, execution metadata, or usage-pricing breakdown for Agent Mode runs); **`null`** for edited rows or when no model can be resolved. |
| tokens | Object `{ "input", "output", "total" }` when token billing applies. For normal chat, values come from `detailed_credits` when `metric == "token"`. For **Agent Mode** runs, values come from execution metadata even when `detailed_credits` is zeroed. **`null`** for image, video, and voiceover (billed per execution, not per token). |
| execution\_mode | **`agent`** for Agent Mode runs, **`chat`** for normal chat conversations, or **`null`** for non-chat execution types. Helps distinguish agent orchestration from standard chat when reviewing usage. |
| link | URL or app path to open the resource when applicable; **`null`** for `archived` and `edited`, and for types without a link. **Chat (current):** path `/dashboard/user/ai/chat/ai-chat/{slug}?_chat_id={id}` using **`root_id`** when set, else row **`id`**. **Image / video / voiceover (current):** signed or public URL from storage when `output` is usable; otherwise **`null`**. |
### **Errors**
| **Status** | **When** |
| :--------- | :---------------------------------------------------------------------------------------------------------------------------------------- |
| 401 | Missing or invalid authentication (Sanctum). |
| 403 | No access to the workspace, or **`user_id`** targets another user without permission to view their executions. |
| 422 | Invalid query parameters (Laravel validation), invalid or missing workspace id, invalid dates, or a custom range longer than **90 days**. |
Validation errors use the standard Laravel error payload; some workspace errors return JSON `{ "message": "..." }` with a translated message.
# Knowledge Base
Source: https://docs.tess.im/en/workspace/kb
The Knowledge Base in Settings is the "central bank" of all files sent to Tess AI: uploads made in chats, agents, flows, and other areas of the workspace.
Here you can track who uploaded what, when, how many credits are consumed, and where each file is being used.
**How to access it?**
### **What is this Knowledge Base about?**
It's the global file repository of the workspace (images, PDFs, docs, etc.) sent to Tess. It's not the same as the Knowledge Base in Agent Studio (which is the content base linked to a specific agent) or in Chat (linked to that context window).
Here you can see all uploads, regardless of which agent or chat used the file.
In the panel, we see a table structure with:
* File name
* Type (e.g., Image, PDF, Document)
* Created by (who uploaded it)
* Created at (date and time)
* File size
* Credits (when there is associated consumption)
* Links (where the file was included – for example: "Tess 6", agent name, or chat name)
* Filters and search
At the top, you can:
1. Filter by attachment type (Attachment Type):
2. Filter by creator (Created By):
3. Search by file name or user, ideal for quickly locating specific files.
### **Permissions (who sees what)**
They can see all team files in the workspace. They can view associated credits and which chats/agents the files were used in. Ideal for governance, cost management, and information security.
In the individual user view, it's only possible to see their own files that were used in their conversations, the credits consumed in each upload and processing, and the associated chats.
### **What it's for in practice**
Know which files are circulating in Tess, who uploaded them, and where they are being used.
Understand which types of files and flows consume the most credits.
Allows you to review whether there are any improper sensitive documents being used in agents or chats.
Makes it easier to find and reuse materials already sent (manuals, presentations, images, etc.).
# Integration with Zapier
Source: https://docs.tess.im/en/zapier
### **What is Zapier?**
Zapier is an automation platform that connects your favorite apps and automates repetitive tasks without the need for code. With thousands of available integrations, Zapier allows you to create custom workflows between different tools.
### **Benefits of integrating Tess with Zapier**
* Connect Tess to thousands of apps supported by Zapier.
* Automate tasks and reduce manual work.
* Create custom workflows for your business.
* Improve operational efficiency and system integration.
When calling the Tess API from this integration, include `x-workspace-id` (**required as of 2026-09-01**). See [API Overview](/en/api-overview).