# Quickstart
Source: https://docs.deepvista.ai/cli
Install the DeepVista CLI and start capturing knowledge and running AI workflows from your terminal in minutes.
## Install the CLI
Run the install script in your terminal. Requires **Python 3.12+**.
```bash theme={null}
curl -sSL https://raw.githubusercontent.com/DeepVista-AI/deepvista-cli/main/install.sh | bash
```
If Python 3.12 isn't available on your machine, install it first before running the command above.
**Using an AI agent?** Paste this prompt directly into Claude Code, Cursor, or any MCP-compatible agent and it will handle the install for you:
```text theme={null}
Install DeepVista CLI. Visit cli.deepvista.ai for docs.
Install command: curl -sSL https://raw.githubusercontent.com/DeepVista-AI/deepvista-cli/main/install.sh | bash
Requires Python 3.12+. If Python 3.12 isn't available, install it first.
After install, run "deepvista auth login" and share the URL with me so I can authenticate.
```
***
## Authenticate
Once installed, log in to connect the CLI to your DeepVista account.
```bash theme={null}
deepvista auth login
```
This opens a browser window for authentication. Complete the sign-in and copy the code shown.
```bash theme={null}
deepvista auth login --code
```
```bash theme={null}
deepvista auth status
```
You should see your account details confirming a successful connection.
***
## Capture your first note
With the CLI installed and authenticated, save an insight to your knowledge base in one line.
```bash theme={null}
deepvista notes +quick "Your insight here"
```
**Example:**
```bash theme={null}
deepvista notes +quick "Tobi Lütke: the company is a tool to amplify what you love"
```
```text theme={null}
✓ Note saved to knowledge base
id: note_7d3f9a
indexed: semantic + full-text
```
Your note is immediately indexed for both semantic and full-text search — ready for your agent to find and synthesize later.
***
## Skills
The CLI ships with **8 built-in skills** that install globally to `~/.claude/skills/` and are available in every agent session automatically.
| Skill | What it does |
| - | - |
| `deepvista-shared` | Auth, profiles, global flags, and security rules used across all skills |
| `deepvista-memory` | Search, read, create, and update cards in your knowledge base |
| `deepvista-notes` | Quick note capture — one-liners or full structured notes, instantly indexed |
| `deepvista-recipe` | Run structured AI workflows and stream results live in your terminal |
| `deepvista-chat` | Conversational AI agent with full access to your knowledge base context |
| `deepvista-persona-knowledge-worker` | Daily knowledge workflow patterns for people who think for a living |
| `deepvista-recipe-research-to-recipe` | Full pipeline: search your KB → synthesize → run a Recipe workflow |
| `deepvista-recipe-export-knowledge-as-skills` | Turn your own knowledge base into installable, shareable agent skills |
***
## Try a use case
Copy any prompt below, paste it into your AI agent (Claude Code, Cursor, etc.), and let DeepVista handle the rest.
Build a searchable knowledge base from founder interviews.
```text theme={null}
Load skills: deepvista-shared deepvista-notes
I just listened to the Lenny's Podcast episode with Brian Chesky about founder mode.
Here are my notes: ...
Save this to my knowledge base as a note titled "Brian Chesky — Founder Mode".
```
Once you've captured 10–20 notes, ask your agent to find patterns across them.
```text theme={null}
Load skills: deepvista-shared deepvista-memory deepvista-recipe deepvista-recipe-research-to-recipe
Search for cards about growth and early-stage execution, then find my Research Synthesis
recipe and run it focused on: what separates high-growth founders, common 0→1 mistakes.
Show me what you find before running.
```
Test new ideas against founder frameworks you've already captured.
```text theme={null}
Load skills: deepvista-shared deepvista-memory deepvista-recipe
I have a new startup idea to evaluate. Idea: [your idea].
1. Search my knowledge base for any idea validation frameworks
2. Find my idea evaluation Recipe
3. Run it with the above context — show me the Recipe first
```
***
## Recipe patterns
Build these workflows in the DeepVista web app, then invoke them through your agent with a single prompt.
```text theme={null}
Search my memory for [topic] and run my Research Synthesis Recipe
```
```text theme={null}
Evaluate this idea against my founder frameworks: [idea]
```
```text theme={null}
Run my weekly review — surface pinned cards and capture this week's key learnings
```
```text theme={null}
I just finished a user interview. Run my Interview Debrief Recipe with these notes: [notes]
```
```text theme={null}
Help me think through this decision using my knowledge base: [decision]
```
```text theme={null}
Run a competitive analysis on [company/space] using everything I've captured
```
***
## CLI reference
| Command | Description |
| - | - |
| `deepvista auth login` | Open browser for authentication |
| `deepvista auth login --code ` | Paste code from browser |
| `deepvista auth status` | Check authentication state |
| `deepvista auth logout` | Clear credentials |
| Command | Description |
| - | - |
| `deepvista notes +quick ""` | Capture a quick one-line note |
| `deepvista notes create` | Create a note with a title and body |
| `deepvista notes list` | List recent notes |
| `deepvista card +search "" --type note` | Search notes by keyword or semantic query |
| Command | Description |
| - | - |
| `deepvista card +search ""` | Search context cards semantically |
| `deepvista card get ` | Retrieve a specific card by ID |
| `deepvista card create` | Create a new context card |
| `deepvista card update ` | Update an existing card |
| Command | Description |
| - | - |
| `deepvista skill list` | List available Skills in your project |
| `deepvista skill run ` | Run a Skill by ID |
| `deepvista skill get ` | Inspect a Skill and its run status |
***
## Uninstall
To remove the DeepVista CLI from your system:
```bash theme={null}
curl -sSL https://raw.githubusercontent.com/DeepVista-AI/deepvista-cli/main/uninstall.sh | bash
```
***
Want to use DeepVista directly inside Cursor or Claude Desktop? Set up the MCP server to give your AI tools live access to your context cards.
# Welcome to DeepVista
Source: https://docs.deepvista.ai/index
DeepVista turns your GTM busywork into reusable workflows for marketing, sales, and customer success. It closes one continuous growth loop that acquires, engages, and retains your customers.
# Core concepts
Context card captures **entities.**
Every team member, customer, meeting note, file, and session is stored within a context card.
VistaBase understands **relationships.**
Every time you chat with DeepVista, VistaBase automatically updates its understanding of your GTM busywork into one connected knowledge base.
With an accurate understanding, agents **act** on real-time intelligence through a set of defined workflows.
WorkBench gives you and your team control in a project.
Search context cards, check scheduled jobs, and share knowledge across your team.
# How DeepVista works
DeepVista turns your unstructured, raw input into context cards.
DeepVista creates workflows personalized to how you work, then executes them end-to-end.
DeepVista works best when everyone in a project shares knowledge with one another.
# Where to start
Build your customer growth flywheel.
A light Workflow is designed for you to "chat, run, and go", with minimal setup required.
# LinkedIn Message Unipile Auto-Response Workflow
Source: https://docs.deepvista.ai/linkedin_message_workflow
````text theme={null}
# LinkedIn Message Unipile Auto-Response Workflow
---
name: workflow-unipile-linkedin-message-response
description: "Process Unipile LinkedIn message webhooks, deduplicate replies, analyze follower count, draft non-commitment response, auto-reply via Unipile API, and send email notification."
type: workflow
execution: stateful
inputs:
- name: webhook_payload
type: object
source: user
label: "Unipile Webhook Payload"
field: textarea
required: true
placeholder: '{"event": "message_received", "message_id": "msg_XXXXXXXX", "chat_id": "chat_XXXXXXXX", "account_id": "{{UNIPILE_ACCOUNT_ID}}", "sender": {"name": "Jane Doe", "profile_url": "https://linkedin.com/in/janedoe", "followers_count": 15400}, "message": "what time works best"}'
help: "Inbound JSON webhook payload from Unipile containing message_id, chat_id, account_id, message, and sender details"
- name: unipile_dsn
type: string
source: user
label: "Unipile DSN"
required: false
placeholder: "apiXX.unipile.com:PORT"
help: "Unipile API server host and port (from your Unipile dashboard). Only needed for the direct-API fallback; not required when using the DeepVista MCP send_linkedin_message tool."
- name: unipile_api_key
type: string
source: secret
label: "Unipile API Key"
required: false
help: "Unipile X-API-KEY. Only needed for the direct-API fallback (DeepVista MCP handles credentials server-side). Store as a secret / environment variable (UNIPILE_API_KEY) — never hardcode in this skill."
- name: unipile_account_id
type: string
source: user
label: "Unipile Account ID"
required: false
placeholder: "acct_XXXXXXXX"
help: "The Unipile account ID of the LinkedIn account this workflow monitors. If unset, resolve it via DeepVista MCP: search context cards for 'LinkedIn account connected', or run the create_linkedin_auth_link setup flow (see Setup & Prerequisites)."
- name: recipient_email
type: string
source: user
label: "Notification Recipient Email"
field: email
required: true
placeholder: "user@example.com"
help: "Email address where the confirmation, auto-sent reply, follower count, and thread link will be sent"
---
## Setup & Prerequisites (via DeepVista MCP)
Before running the workflow, verify all requirements are satisfied. If anything is
missing, use the DeepVista MCP tools to complete the setup **conversationally** —
walk the user through it in chat rather than telling them to leave and configure
things manually.
### Requirement checklist
| Requirement | How to check | How to fix via MCP |
|---|---|---|
| LinkedIn account connected to Unipile | `search_context_cards` for a card titled "LinkedIn account connected" (tags: `LinkedIn`, `Unipile`) containing `unipile_account_id` | Call `create_linkedin_auth_link` and guide the user through it (see below) |
| `unipile_account_id` | Read it from the same context card | Filled automatically once the auth flow completes |
| `unipile_dsn` / `unipile_api_key` | Only needed for the raw-curl path (Step 5 fallback); not needed when using MCP tools | Prefer the MCP `send_linkedin_message` tool, which handles credentials server-side — never ask the user to paste an API key into chat |
| Notification email | Confirm `recipient_email` with the user | `send_notification_email` needs no setup; `send_email` requires the user's connected Gmail account |
### Connecting LinkedIn through chat
If no LinkedIn account is connected yet:
1. Call the DeepVista MCP tool `create_linkedin_auth_link` (optionally passing a
`success_redirect_url`). It returns a Unipile **hosted auth URL**.
2. Show the URL to the user and ask them to open it in a browser and sign in to
LinkedIn. The connection completes out-of-band — DeepVista is notified via the
`account.connected` webhook, which records the new `unipile_account_id` in a
context card ("LinkedIn account connected") tied to the user.
3. After the user says they've finished, re-run `search_context_cards` for the
connection card to pick up `unipile_account_id`. If it hasn't appeared yet,
wait briefly and retry, or ask the user to confirm the browser flow succeeded.
4. Never guess or fabricate an `account_id` — only use one recorded by the webhook
or explicitly provided by the user.
### Preferred send path
When the DeepVista MCP `send_linkedin_message` tool is available, use it instead of
the raw Unipile curl in Step 5 — it sends from the user's connected account using
server-side credentials (`account_id`, recipient provider id, message text) and
returns `chat_id` / `message_id` for the notification step. Fall back to the direct
Unipile API only when the MCP server is unavailable and the user has supplied
`unipile_dsn` + `unipile_api_key` as secrets.
## Workflow
```mermaid
flowchart TD
Input["Input"]:::dvTodo
A["1. Receive & Parse Unipile Webhook"]:::dvTodo
subgraph rowB [ ]
direction TB
B["2. Check Reply Status & Deduplicate"]:::dvTodo
noteB["Terminated: self-sent message (is_sender: true)"]:::dvNote
end
C["3. Analyze Message, Profile & Follower Count"]:::dvTodo
D["4. Draft Response (No Scheduling/Times)"]:::dvTodo
E["5. Post Reply into Existing Chat Thread"]:::dvTodo
F["6. Send Confirmation Email & Notify"]:::dvTodo
Output["Output"]:::dvTodo
Input e0@--> A
A e1@--> B
B e2@--> C
C e3@--> D
D e4@--> E
E e5@--> F
F e6@--> Output
e0@{ animation: slow }
e1@{ animation: slow }
e2@{ animation: slow }
e3@{ animation: slow }
e4@{ animation: slow }
e5@{ animation: slow }
e6@{ animation: slow }
````
## Node Description
1. Receive & Parse Unipile Webhook
*Estimated time: \~1 min (from 1 run)*
1. Intercept inbound webhook payload triggered by Unipile on a new LinkedIn message targeting account `{{unipile_account_id}}`.
2. Extract required identifiers: `message_id`, `chat_id` (existing Unipile conversation ID), `account_id`, sender name, LinkedIn profile URL, message text, thread URL, and follower count.
3. Validate presence of `message_id` and `chat_id`.
2. Check Reply Status & Deduplicate
*Estimated time: \~1 min (from 5 runs)*
1. Query VistaBase (`database_search` / `search_context_cards`) for existing cards matching `message_id` or `chat_id`.
2. Check if a reply has already been generated or sent for this specific message or thread state.
3. **If already replied or self-sent message**: Terminate workflow execution immediately without drafting or posting a new message to prevent duplicate replies.
3. Analyze Message, Profile & Follower Count
*Estimated time: \~1 min (from 3 runs)*
1. Retrieve sender profile metadata to confirm LinkedIn follower count.
2. Search VistaBase (`database_search` / `search_context_cards`) for existing `person` or `organization` context.
3. Determine intent, core questions, and priority tier (e.g. High Priority: >10k followers).
4. Draft Response (No Scheduling/Times)
*Estimated time: \~1 min (from 3 runs)*
1. Synthesize a polite, engaging, and professional response aligned with founder tone.
2. **Strict Guardrails & Zero Commitments**:
* **No Promises of Meetings**: Do NOT promise a meeting, call, coffee chat, or follow-up conversation.
* **No Promises of Collaboration**: Do NOT promise partnerships, joint projects, advisory roles, or investments.
* **No Scheduling/Times**: Do NOT offer specific times, suggest scheduling slots, propose PST/EST hours, or share calendar links.
3. Focus purely on acknowledging the message politely, expressing appreciation, or acknowledging key points without making commitments.
4. Construct request payload for Unipile's send-message endpoint (`POST https://{{unipile_dsn}}/api/v1/chats/{chat_id}/messages`).
5. Post Reply into Existing Chat Thread
*Estimated time: \~1 min (from 2 runs)*
1. **Preferred**: call the DeepVista MCP tool `send_linkedin_message` with the connected `account_id`, the recipient's provider id, and the drafted text — it returns `chat_id` / `message_id` on success. If no account is connected, run the `create_linkedin_auth_link` setup flow first (see Setup & Prerequisites).
2. **Fallback** (only if the MCP server is unavailable and `unipile_dsn` + `unipile_api_key` are provided): execute a POST request targeting the existing chat thread endpoint:
```yaml theme={null}
prompt: |
curl --request POST \
--url https://{{unipile_dsn}}/api/v1/chats/{{chat_id}}/messages \
--header "X-API-KEY: $UNIPILE_API_KEY" \
--header 'accept: application/json' \
--header 'content-type: multipart/form-data' \
--form 'text={{generated_reply}}'
```
3. Confirm success (MCP `status: "sent"` or HTTP 200/201) and capture the returned message ID.
6. Send Confirmation Email & Notify
*Estimated time: \~1 min (from 3 runs)*
1. Format notification email summarizing:
* **Sender**: Name, LinkedIn profile link, and **Follower Count**
* **Thread & Message ID**: `chat_id` / `message_id`
* **Status**: Auto-replied directly into existing LinkedIn thread
* **Received Message**: Full text of incoming message
* **Sent Auto-Reply**: Exact text delivered to LinkedIn
* **LinkedIn Thread Link**: Direct link for manual review or follow-up
2. Deliver email to `recipient_email` via `send_email` or `send_notification_email`.
3. Persist a `message` card in VistaBase tagged with `message_id` and `chat_id` to block duplicate future triggers.
```text theme={null}
```
# MCP Server
Source: https://docs.deepvista.ai/mcp-server
Connect your AI tools (Cursor, Claude Desktop, and more) directly to your DeepVista context cards.
The DeepVista MCP server lets any compatible AI client read, search, create, edit, and delete your context cards — without leaving your coding environment or chat interface.
All actions are automatically scoped to your **currently active DeepVista project**. No extra configuration needed.
MCP (Model Context Protocol) is an open standard for connecting AI clients to external data sources. [Read the spec →](https://modelcontextprotocol.io/specification/2025-03-26)
## Endpoint
The MCP server uses **Streamable HTTP transport** with OAuth 2.1 authentication.
```text theme={null}
https://api.deepvista.ai/mcp
```
***
## Setup
Add the following to your Cursor MCP config file at `~/.cursor/mcp.json`. Create the file if it doesn't exist.
```json ~/.cursor/mcp.json theme={null}
{
"mcpServers": {
"deepvista": {
"url": "https://api.deepvista.ai/mcp"
}
}
}
```
Press `Cmd/Ctrl+Shift+P` and run **MCP: Connect to server**.
A browser window will open — complete the OAuth flow to authorize the connection.
Return to Cursor. The server status should show **Connected**.
**Verify it's working:** In Cursor's AI chat, type `List my DeepVista context cards.` You should see a summary of cards from your active project.
Open or create your Claude Desktop config file and add the DeepVista server entry.
```json ~/Library/Application Support/Claude/claude_desktop_config.json theme={null}
{
"mcpServers": {
"deepvista": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://api.deepvista.ai/mcp"
]
}
}
}
```
On Windows the config file is at `%APPDATA%\Claude\claude_desktop_config.json`.
Claude Desktop uses `npx` to launch the bridge — Node.js 18+ is required. Run `node --version` to confirm.
Use `Cmd+Q` on macOS or right-click the taskbar icon and select **Quit**.
A browser window will prompt you to sign in to DeepVista.
You'll be redirected back to Claude automatically once authorized.
**Verify it's working:** Start a new Claude conversation and ask `Show me my recent DeepVista context cards.` A list from your active project should appear.
Run the following command to add the DeepVista MCP server:
```bash theme={null}
claude mcp add --transport http deepvista-server https://api.deepvista.ai/mcp
```
Then open a Claude Code session and run `/mcp` to go through the authentication flow.
**Verify it's working:** Ask Claude Code to `search my DeepVista cards for [any topic]`. A matching result confirms the connection is live.
Press `Ctrl/Cmd+Shift+P`, search for **MCP: Add Server**, select **Command (stdio)**, and enter:
```text theme={null}
npx mcp-remote https://api.deepvista.ai/mcp
```
Name the server **deepvista** and hit enter. Then activate it via **MCP: List Servers** → select **deepvista** → **Start Server**.
Alternatively, add it directly to your settings:
```json theme={null}
{
"mcpServers": {
"deepvista": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://api.deepvista.ai/mcp"]
}
}
}
```
Press `Ctrl/Cmd+,` to open Windsurf settings. Scroll to **Cascade → MCP servers**, then select **Add Server → Add custom server** and paste:
```json theme={null}
{
"mcpServers": {
"deepvista": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://api.deepvista.ai/mcp"]
}
}
}
```
Hundreds of tools now support MCP. Use these settings for any client not listed above.
**Native remote MCP (Streamable HTTP):**
```text theme={null}
URL: https://api.deepvista.ai/mcp
Auth: OAuth 2.1 (dynamic client registration)
```
**Via `mcp-remote` bridge (stdio clients):**
```text theme={null}
command: npx
args: -y mcp-remote https://api.deepvista.ai/mcp
```
After adding the server, your client will open a browser window for the OAuth sign-in flow.
**Verify it's working:** Ask your AI to `search my DeepVista cards for [any topic you have a card on]`. A matching result confirms the connection is live.
***
## What you can do
Once connected, talk to your AI naturally. Here are some example prompts to get started.
| Action | Example prompt |
| - | - |
| **Find** | `Find my context cards about machine learning pipelines` |
| **Search** | `Which cards mention series A fundraising?` |
| **Create** | `Create a new context card for Acme Corp — Q3 partnership notes` |
| **Update** | `Update my card on Sarah Chen with: joined the advisory board in May` |
| **List** | `Show me all context cards I've updated this week` |
| **Delete** | `Delete the context card titled Old vendor contract` |
The AI will always confirm before deleting a card. To switch projects, change your active project in DeepVista — the MCP connection reflects it immediately.
***
## Troubleshooting
Open [deepvista.ai](https://deepvista.ai) in your browser and confirm you're signed in to the correct account. Then return to your AI client and try connecting again.
If the issue persists, clear the stored auth cache and retry:
```bash theme={null}
rm -rf ~/.mcp-auth
```
Double-check that the endpoint URL in your config is exactly `https://api.deepvista.ai/mcp` — no trailing slash.
If you're using the `mcp-remote` bridge, confirm Node.js 18+ is installed:
```bash theme={null}
node --version
```
The MCP server returns cards from your **currently active project**. Open DeepVista and confirm the correct project is selected in the project switcher. An empty list is expected if the active project has no cards yet.
Use this WSL-compatible configuration instead:
```json theme={null}
{
"mcpServers": {
"deepvista": {
"command": "wsl",
"args": ["npx", "-y", "mcp-remote", "https://api.deepvista.ai/mcp"]
}
}
}
```
Clear saved auth info and try again:
```bash theme={null}
rm -rf ~/.mcp-auth
```
You may also need to update to a newer version of Node.js if your current version is below 18.
***
Capture notes and run workflows from your terminal using the DeepVista CLI.
Sign up to start connecting your AI tools to DeepVista.
# Social Media Management
Source: https://docs.deepvista.ai/social-media-management
Automate your social distribution and inbound engagement without losing personal context or sending generic AI responses.
![Top 10 LinkedIn contacts to focus on, ranked by ICP fit, engagement status, and deal priority]()
## What you can do
**Ask DeepVista:**
* "List top 10 LinkedIn contacts I should focus on today."
* "Draft personalized messages for them."
* "Update lead status on the CRM tracker."
**Our Core Playbook:** This is the exact workflow our team uses to handle inbound DMs, auto-reply on LinkedIn and X, and draft structured social posts from product updates.
## Who should read this
This guide is designed for **founders, marketing operators, and developer advocates** who want to maintain an active social presence and respond instantly to inbound interest.
You should follow this playbook if you:
* **Receive inbound messages or comments on LinkedIn and X** and want contextually relevant replies drafted automatically.
* **Want to capture leads from social interactions** directly into your VistaBase CRM tracker.
* **Convert internal notes, product updates, or trending topics** into ready-to-publish X posts.
## 1. LinkedIn Auto-Reply
Auto-reply to new LinkedIn messages triggered by a webhook using a Unipile account.
* Please sign up an DeepVista account at [https://app.deepvista.ai](https://app.deepvista.ai)
* Please sign up an Unipile account at: [https://dashboard.unipile.com/signup/](https://dashboard.unipile.com/signup/)
### Connect Unipile and DeepVista
```text wrap theme={null}
Set up a workflow based on https://raw.githubusercontent.com/DeepVista-AI/ai-native-skills/refs/heads/main/skills/workflow-unipile-linkedin-message-response.md. Guide me through the set up (including setting up Linkedin and Webhook in unipile)
```
![Image]( "Image")
![Generating a Unipile access token]()
You'll find it in the top-left corner of the sidebar.
![Unipile dashboard with the DSN highlighted in the sidebar]()
```text theme={null}
Here's the command and the DSN:
```
### Authorize LinkedIn
DeepVista will create a Linkedin authorization link.
![Image]()
![Image]( "Image")
Then put your linkedin credential to login. Note that this is a [unipile.com](http://unipile.com) authorization page.
### Go Live
`Set up the workflow webhook callback URL using manage_skill_webhook.`
It will set up the webhook connection for you.
You're ready to auto-reply to any new LinkedIn messages. You can test it by having your friend to message you.
# Apollo Integration
Source: https://docs.deepvista.ai/tutorials/apollo-integration
Connect Apollo to DeepVista and get people-search results verified against Apollo's own database, right inside your CRM tracker.
## Overview
DeepVista can query Apollo's people-search database directly.
Apollo's direct people-search endpoint requires an **Apollo Master API Key**.
## Prerequisites
* A DeepVista account with an active project. [Sign up here](https://app.deepvista.ai/login?redirectUrl=%2Fsign%2520in) if you don't have one.
* An [Apollo](https://www.apollo.io) account with a Master API Key. In Apollo, go to **Settings → Integrations → API** to generate one.
## Step-by-step guide
DeepVista returns a **Connect Apollo Integration** link through Composio. This link is valid for 10 minutes.
![DeepVista chat with a Connect Apollo Integration link and next steps for authorizing the connection]()
Open it in your browser and enter your Apollo API key on the authorization screen.
Try a prompt like:
```text theme={null}
Find 20 Seed/Series A B2B SaaS founders in the US.
```
DeepVista returns a tracker sourced directly from Apollo, with every row's `Source` column set to `Apollo`.
![A US B2B SaaS Founders (Apollo Verified) tracker with a Source column set to Apollo on every row]()
## Next steps
Build your CRM tracker, then point it at Apollo for verified contact data.
Feed Apollo-verified leads straight into a campaign's lead capture flow.
# Customer Research & Tracking
Source: https://docs.deepvista.ai/tutorials/customer-research-and-tracking
Speed up customer acquisition with an intelligent system that captures, researches, and follows up for you.
**Our Core Playbook:** This is the exact workflow our internal team uses daily to research leads, automate CRM updates, and handle outbound outreach.
## Who should read this
* **Founders & Operators**: Automate GTM busywork and maintain pipeline visibility.
* **Growth & Sales Leads**: Qualify inbound leads and draft personalized outreach instantly.
## What you'll learn
* Build your own intelligent CRM tracker in minutes.
* Learn how DeepVista handles the busywork for you by researching outbound leads, sending outreach emails, and capturing and following up with inbound leads.
* Win the new metric for AI-native GTM: [Speed to context](https://foundercoho.substack.com/p/speed-to-context-the-new-metric-for?utm_source=publication-search).
## 1. Research Leads and Set Up a CRM Tracker
### Prerequisites
Before you start, make sure you have a DeepVista account with an active project.
To create an account, [sign up here](https://app.deepvista.ai/login?redirectUrl=%2Fsign%2520in).
Once you're in, you'll land on your homepage with quick-start cards, ready to go.
![]()
### Onboard Your Company and Ask DeepVista to Search Leads for You
DeepVista will ask for your company website, confirms your ICP, and learns your value propositions and key capabilities.
A **workbench** helps you organize all assets you've created.
In this case, you can automatically add future outputs from this chat and find them later on the homepage.
![]()
![]()
![]()
### Customize Your Search Fields
1. To retrieve additional information, prompt DeepVista: "Please add a column for the LinkedIn page. Research and populate it." The system will automatically add and populate the new column with the requested data.
![]()
Want contacts verified against a live database instead of deep research? Connect [Apollo integration](/tutorials/apollo-integration) for **Apollo Verified** tracker rows.
## 2. Draft, Send, and Schedule Outreach Email
### Ask DeepVista to Draft Outreach Email
DeepVista will save your email drafts as context cards.
![]()
![Image]()
To make changes, you can also ask DeepVista directly: "Add my email signature."
DeepVista will automatically pull the necessary information from your VistaBase context cards.
### Connect Your Gmail and Send Your Email
![]()
![]()
![]()
![]()
### Ask DeepVista to Schedule a Daily Job
DeepVista will create an automated **workflow** and a **scheduled job** for you.
![]()
![]()
## 3. Keep Your CRM Running With You
### Capture a Note or a Screenshot
1. Copy and paste it in chat, ask DeepVista to "add customer A to my CRM Tracker." DeepVista will automatically update the row.
![]()
### Monitor your Email
DeepVista will create a **Scheduled job** to run the monitor **workflow** automatically.
![]()
![]()
![]()
## Congratulations
You just built an intelligent CRM Tracker. Start acquire, engage, and retain!
# Install Coding Dependencies on Mac
Source: https://docs.deepvista.ai/tutorials/mac-setup
Install the command-line tools, Homebrew, Python, Node.js, and the Claude Code CLI you'll need before running DeepVista's other setup tutorials.
## Overview
To run a deep workflow, DeepVista's CLI and local-agent tooling require a handful of standard developer tools installed on your machine: `git`, Python 3.12+, Node.js 18+, and the Claude Code CLI.
Already have some of these installed? Each step includes a version check — skip any step where the check already succeeds.
## Step-by-step guide
Provides `git`, `clang`, and the other build tools macOS needs.
```bash theme={null}
xcode-select --install
```
A software update dialog opens — click **Install**, accept the license, and wait for the download to finish.
![Installing Xcode Command Line Tools]()
Verify it worked:
```bash theme={null}
xcode-select -p
```
Homebrew is the package manager used to install everything else in this tutorial.
```bash theme={null}
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
![Installing Homebrew]()
Verify it worked:
```bash theme={null}
brew --version
```
Required by the DeepVista CLI installer.
```bash theme={null}
brew install python@3.12
```
![Installing Python 3.12]()
Verify it worked:
```bash theme={null}
python3.12 --version
```
Required for the Claude Code CLI and DeepVista's local tooling.
```bash theme={null}
brew install node
```
![Installing Node.js]()
Verify it worked:
```bash theme={null}
node --version
```
You'll use this later to run `claude login` when connecting your machine to DeepVista.
```bash theme={null}
npm install -g @anthropic-ai/claude-code
```
![Installing the Claude Code CLI]()
Verify it worked:
```bash theme={null}
claude --version
```
Run all four checks together:
```bash theme={null}
git --version
python3 --version
node --version
claude --version
```
Each command should print a version number, not a "command not found" error.
![Verifying all dependencies are installed]()
## Next steps
Authenticate Claude Code and configure the connectors your workflows will use.
# Setting Up the Rebrandly CLI for DeepVista Task Delegation
Source: https://docs.deepvista.ai/tutorials/rebrandly-cli-delegation
Generate custom short links through DeepVista workflows using the Rebrandly CLI on a connected machine, while keeping your API key out of regular chat history.
## Overview
Integrating the **Rebrandly CLI** with DeepVista lets your workflows create, customize, and manage branded short URLs (e.g. `link.yourdomain.com/xyz`) directly from prompts.
Your Rebrandly API key is given to DeepVista once, through a **sensitive message** in chat, a message DeepVista doesn't save to chat history. From there, the key is only ever used by your connected machine to run Rebrandly CLI commands; it's never handled as regular chat text or stored in a normal message.
## Prerequisites
Deep Workflows need a connected machine before you can run them. Complete these three setup steps first, in order:
Install the developer tools and Claude Code CLI this setup depends on.
Authenticate Claude Code with your Claude account.
Install the DeepVista CLI and connect your machine as a local runner.
With your machine connected and `deepvista tasks run` polling, you'll also need a [Rebrandly](https://www.rebrandly.com) account with an active workspace API key.
## Step-by-step guide
In Rebrandly, click your account menu and select **Settings**.
![Rebrandly account menu open, with Settings highlighted]()
Under **Connections & Data**, select **API Keys**.
![Rebrandly Settings page with the API Keys section selected, showing a masked API key]()
Click the **Copy** button next to your key.
![Copy button highlighted next to a masked Rebrandly API key]()
Back in DeepVista chat, paste the key using the **sensitive message** toggle (the crossed-out eye icon next to send). Messages sent this way are delivered to your connected machine but are not saved to chat history.
![DeepVista chat with the sensitive-message toggle enabled, showing a redacted API key that won't be saved]()
This is the recommended way to hand off any credential to DeepVista. It's simpler than manually creating a local config file, and the key still never appears in your regular chat history.
Done, you can now rebrand any link in a DeepVista workflow just by chatting.
## Next steps
See the same local-credential pattern used to file Linear tickets headlessly.
Research, draft, and publish X posts with the Buffer CLI.
# Set Up Your Claude Code Connector
Source: https://docs.deepvista.ai/tutorials/server/claude-connector-delegation
Connect your machine to Claude Code Connectors and delegate any task by chatting with DeepVista.
## Overview
By the end of this tutorial, Claude Code will be authorized on your machine, you'll see which connectors are available to it, and you'll try delegating a task to one directly from DeepVista chat.
## What are you actually connecting?
Deep workflows ask you to set up **Claude Code**. Here's what happens every time you run a deep workflow:
* **Claude Code** runs on your own computer and signs in with your own Claude account. Your password never passes through our servers.
* On **Claude.ai**, you turn on a setting that lets Claude read a tool you've connected, like Google Drive.
* From there, DeepVista works through the Claude Code on your computer to fetch what it needs and bring the results back to you.
This uses your own Claude subscription's usage allowance, not a DeepVista quota.
## Prerequisites
Before you start, make sure you have:
1. A DeepVista account with an active project
2. The Claude Code CLI installed (see [Mac Setup](/tutorials/mac-setup))
3. A Claude account to authorize the connector with
## Step-by-step guide
On your machine, authenticate your terminal with Claude:
1. Open your terminal.
2. Run the following login command:
```bash theme={null}
claude login
```
3. Select the login method: **Claude account with subscription**.
![Terminal prompt to select a Claude login method]()
4. Your browser will automatically open to sign in (or you can copy the terminal-provided URL). It asks you to authorize Claude Code to connect to your Claude account.
5. Once signed in, an authentication code will be provided in your browser window.
6. Copy and paste this code back into the terminal prompts. The terminal confirms you're logged in.
![Terminal confirming a successful Claude login]()
To manage what's connected, open **Claude → Customize**.
![Claude sidebar with Customize highlighted]()
From there, **Connectors** shows every integration available to that machine and whether it's connected.
![Connectors settings page listing available integrations and their connection status]()
Once authorized, your machine gains the superpower of running background workflows using any of the available Claude Connectors configured on your account.
**Integrations:** Google Drive, Microsoft 365, Notion
Read, write, and index files automatically.
**Integrations:** Gmail, Slack, MS Teams
Draft replies, summarize emails, and send automated reports.
**Integrations:** GitHub, Linear
Manage repositories, pull requests, and delegate ticket creation.
**Integrations:** Figma, Canva
Generate diagrams, grab design specs, and create layouts.
**Integrations:** Google Calendar
Coordinate meetings and manage schedules autonomously.
## Try a simple task with a Claude Code Connector
For example, once Google Drive is connected, `@mention` your machine in DeepVista chat (type `@` followed by its name) to send it a task directly, and ask something like:
```text theme={null}
I have already authed the Google Drive connector, can you list all my recent Google files?
```
Your machine picks up the task, opens the connector, and returns the results right in chat — no need to open Google Drive yourself.
![Chat response listing recent Google Drive files through a connector on a connected machine]()
Try it yourself: pick any connector you already have configured — Slack, Notion, GitHub, whatever your machine has access to — and send a similar prompt from DeepVista chat. You'll get results back the same way, without leaving the conversation.
## Next steps
Turn your desktop, laptop, or on-premise server into an active DeepVista runner.
# Connect Your Own Machine
Source: https://docs.deepvista.ai/tutorials/server/local
Connect your local desktop, laptop, or on-premise server as an active DeepVista runner with a single command.
## Prerequisites
Before you start, make sure you have:
1. A DeepVista account with an active project
2. Claude Code Connectors set up
## Step-by-step guide
Go to **Settings → Machines**, then under **Connect your machine**, click **Open Terminal**.
![Settings > Machines page with the Open Terminal button highlighted]()
Copy the command shown, paste it into your terminal, and hit **Return**.
The command installs the DeepVista CLI and Claude Code (skipping anything already installed), then starts listening for tasks.
![Terminal running the quickstart command, checking off already-installed dependencies before starting the task daemon]()
Already completed [Mac Setup](/tutorials/mac-setup)? Most items will already be checked.
Back in DeepVista, your machine now appears under **Connected machines** with a green dot, ready to receive work.
![Connected machines list showing a machine online with a green status dot]()
Click the send icon next to your machine to send a test task.
![Send test task button next to a connected machine]()
DeepVista reports back your machine's disk usage and configured connectors, confirming everything is wired up correctly.
![DeepVista chat showing a completed test task with disk usage and connector details]()
Once the test task completes, you're ready to run a Deep Workflow.
## Next steps
Let your connected machine create Linear tickets headlessly, from a cloud-triggered prompt.
Research, draft, and publish X posts with the Buffer CLI.
# Dedicated Private Server
Source: https://docs.deepvista.ai/tutorials/server/private
Run your workflows 24/7 without keeping your local machine active by setting up a dedicated, fully managed DeepVista Private Server.
For production-grade environments, complex automations, or enterprise workloads, relying on a personal computer is often impractical. DeepVista provides fully managed, dedicated private servers that run constantly in the cloud.
This is an alternative to [Connect Your Own Machine](/tutorials/server/local), not a follow-on step — pick whichever fits your workload, you don't need to do both.
![Direct Workflow Editing]()
Keep your workflows running 24/7 without needing to leave your laptop or local desktop powered on.
## Step-by-step guide
To provision a new managed instance:
1. Send an email to [support@deepvista.ai](mailto:support@deepvista.ai).
2. Our engineering and account team will follow up to discuss your workload requirements, resource allocation, and custom pricing/negotiation talks.
3. Once finalized, we will provision your dedicated instance, and it will appear directly under the **Private server** section in your dashboard.
Once your dedicated private server is active, authenticate it with Claude the same way you would any connected machine — see the linked tutorial below for the full walkthrough.
## Next steps
Authenticate your terminal with Claude and start delegating tasks to this server.
# Social Media Campaign
Source: https://docs.deepvista.ai/tutorials/social-media-campaign
Build a 10-day lead generation sprint that creates your social media copy and tracks incoming leads automatically.
**Our Core Playbook:** This is the exact workflow our internal team uses to turn existing content into a 10-day social campaign with built-in lead tracking.
## What you'll get
* **10 days of ready-to-post content**, delivered to your inbox each day.
* **A unique tracking link for every post**, so you can see which post drives leads.
## Who should read this
* **Founders & Marketers**: Turn existing content into a steady drumbeat of social posts without writing from scratch.
* **Growth Leads**: Know exactly which post is driving inbound leads.
## What you'll learn
* Build a content library from a piece of content you already have (a landing page, release note, or tutorial).
* Turn that library into a 10-day campaign with a lead capture form on every post.
* Get your daily post emailed to you and start tracking which posts convert.
* Get notified the moment a lead comes in, and follow up automatically.
## 1. Research & Create a Content Library
### Prerequisites
Before you start, make sure you have a DeepVista account with an active project.
To create an account, [sign up here](https://app.deepvista.ai/login?redirectUrl=%2Fsign%2520in).
### Ask DeepVista to research and draft your content library
Provide an input — your landing page, a product release note, a tutorial, or any content asset you already have.
For example, we used this prompt:
```text wrap theme={null}
Research published tutorials from https://docs.deepvista.ai/ and propose 10 copies targeting my ICPs.
```
DeepVista researches the source content and drafts 10 posts targeting your ICPs.
![DeepVista generates a post from your source content]()
## 2. Build a 10-Day Campaign
### Schedule the campaign
DeepVista schedules your content library into a 10-day campaign, one post per day.
![DeepVista content library scheduled across a 10-day campaign]()
### Add a lead capture form to each post
Use this prompt:
```text wrap theme={null}
Let's add an input form in each post. When someone fills it out, update the CRM tracker.
```
DeepVista creates a Lead Capture Workflow for the campaign.
Hover over the upper-right corner of the workflow card and generate a URL for your input form.
![DeepVista's lead capture workflow]()
On the workflow page, click **Input** > **Input Form** > **Add input** to get a sample prompt you can edit.
![Publishing an input form from the workflow]()
Each post also gets its own unique tracking link — you'll find it on the workflow card.
![Finding the unique tracking link on a post's workflow card]()
## 3. Get Your Daily Copy & Start Tracking
### Ask DeepVista to email your daily post
Check your inbox — your first post is on its way.
![First campaign post arriving in your inbox]()
Congratulations! You've set up a 10-day social media campaign. Start capturing leads with DeepVista.
## 4. Get Notified & Follow Up with Leads
### Get Notified with Inbound Activities
![]()
![]()
### Follow up with High-fit Leads
![]()
![]()
## Congratulations
You've closed the loop on your social media campaign — from content to conversion, with every lead captured and followed up on automatically.
# Automate Linear Tickets
Source: https://docs.deepvista.ai/tutorials/task-delegation-linear
Learn how to use DeepVista Task Delegation to let a locally-connected CLI agent create Linear tickets headlessly, keeping credentials on your own machine.
## Overview
By the end, DeepVista will file Linear tickets automatically from a cloud-triggered prompt, while your Linear API token never leaves your own machine.
DeepVista provides a powerful **Task Delegation** feature. When a cloud agent encounters an operation that requires a local environment, a specific CLI, or particular credentials (such as an API key), it can package the work as a `task` card and dispatch it to a CLI agent connected on the user's local machine.
This tutorial demonstrates how to configure and use DeepVista Task Delegation to create Linear tickets headlessly and automatically.
## Prerequisites
Deep Workflows need a connected machine before you can run them. Complete these three setup steps first, in order:
Install the developer tools and Claude Code CLI this setup depends on.
Authenticate Claude Code with your Claude account.
Install the DeepVista CLI and connect your machine as a local runner.
With your machine connected and `deepvista tasks run` polling, configure Linear API credentials:
```bash theme={null}
export LINEAR_TOKEN="your_linear_api_token"
```
*Note: The agent retrieves this variable securely within your local environment and never uploads the credential in plaintext or leaks it to logs.*
## Step-by-step guide
In DeepVista, a Task is essentially a Context Card with `type: "task"` and `status: "pending"`. Its `description` contains a YAML metadata prefix along with the specific prompt you want to execute.
**Example card configuration:**
* **Type**: `task`
* **Status**: `pending`
* **Title**: `Create a test Linear ticket`
* **Description**:
```yaml theme={null}
---
agent_id: "your-machine-id" # Fill in the local Machine ID you connected
agent_role: "engineering"
---
Please create a test Linear ticket.
To do this:
1. Search the local machine (environment variables, config files, or helper tools) for any Linear API credentials (such as LINEAR_API_KEY, LINEAR_TOKEN, etc.).
2. If credentials are found, use the Linear GraphQL API (via curl or python) to create a new ticket in an active workspace.
- Title: "DeepVista Test Ticket"
- Description: "This is a test ticket filed automatically by DeepVista agent task delegation."
3. Report the status of the ticket, the ticket key/ID, or a URL to the ticket if successfully created.
```
1. The cloud agent stores this task card in the database.
2. The local CLI agent (polling via `deepvista tasks run`) retrieves the pending task and invokes Claude locally to execute the prompt:
* Claude checks the local environment variable `LINEAR_TOKEN`.
* It sends an `issueCreate` request to Linear via the GraphQL API.
Once execution completes, the local agent writes the run log (`## Run`) and the final result card (`type: "note"`) back to DeepVista, and automatically updates the Task's `status` to `completed`.
**Example final result**:
* **Key**: `DV-1373`
* **Title**: DeepVista Test Ticket
* **URL**: `https://linear.app/deepvista/issue/DV-1373/deepvista-test-ticket`
# Set Up an X Posting Workflow and Post It with Buffer CLI
Source: https://docs.deepvista.ai/tutorials/x-post-workflow
Generate an X posting workflow from a single prompt, extend it in plain language, and publish approved drafts to X using the Buffer CLI.
## Overview
By the end, DeepVista will research, draft, and hold X posts for your review, then publish them for you — from a single prompt, with no manual scheduling.
DeepVista can turn one well-structured prompt into a complete X posting workflow: it researches source content, drafts post variants in your brand voice, holds them for your review, and publishes to your chosen channel. This tutorial walks through generating the workflow, adding a step, and publishing to X with the [Buffer CLI](https://cli.deepvista.ai).
## Prerequisites
Before you start, make sure you have:
1. A DeepVista account with an active project
2. A source of content to draw from (a URL, newsletter, or content type)
3. The Buffer CLI installed and authenticated, with your X (Twitter) channel connected in Buffer
## Step-by-step guide
Paste the following prompt into DeepVista chat:
```text theme={null}
Create an X posting workflow for my company.
```
Add a line defining the themes you want the workflow to prioritize, such as AI/ML, fundraising, GTM, or technical deep-dives. This sharpens what the research step surfaces.
DeepVista generates the full workflow from this prompt. Every draft pauses for your review before anything is published.
DeepVista automatically searches your company context to create a personalized workflow.
![DeepVista generating a workflow from a single prompt]()
The workflow appears in the chat output. Click it to open the full workflow in the right panel.
![Workflow card in the chat output]()
![Full workflow displayed in the right panel]()
You can extend the workflow at any time. Open chat and describe the new step using this pattern:
```text theme={null}
Add a step after [existing step] that [does what].
```
For example:
```text theme={null}
Add a step after "Draft review" that publishes the approved
draft to X using the Buffer CLI.
```
DeepVista handles the technical wiring. You only describe the step.
![Adding a workflow step in plain language]()
First, find the channel ID for your connected X account:
```bash theme={null}
buffer channels list --fields 'items.{id,service,name}' --output json
```
![Listing Buffer channels to find the X channel ID]()
Then tell DeepVista which channel to publish to. Tell DeepVista:
```text theme={null}
Publish approved drafts to X using the Buffer CLI, channel ID:
[paste your channel ID]
```
DeepVista wires the publish step to build a Buffer payload and validate it before sending:
```bash theme={null}
buffer posts create --json "$payload" --dry-run
```
![Dry-running the Buffer post payload before publishing]()
`--dry-run` validates the payload with no API call — DeepVista runs this check on every draft before the real publish, so a malformed post never reaches X.
Once the dry run passes, the workflow sends the real request:
```bash theme={null}
buffer posts create --json "$payload" --output json
```
![Buffer CLI publishing the approved draft to X]()
Click the **Run** button to trigger the workflow.
![Run button on the workflow panel]()
DeepVista populates a predefined prompt that starts the run.
![Predefined prompt that triggers the workflow]()
![Workflow run in progress]()
![Workflow run output with draft for review]()
Once you approve the draft, the workflow publishes it to X via the Buffer CLI.
## Next steps
Explore more tutorials in the DeepVista documentation.
# Version 0.6.1
Source: https://docs.deepvista.ai/version/0-6-1
June 8, 2026
Here is a focused look at our recent feature updates for DeepVista v0.6.1. We’ve streamlined the interface and expanded our AI capabilities to give you more control!
## 🔥 Highlighted Features
### 🤖 Sub-Workflows
* **What’s New:** Workflows can now be broken down into reusable sub-workflows, making it easier to organize and scale complex processes.
* **User Value:** Users can progressively drill into high-level workflows, break them into concrete steps, and develop each part independently. This makes it easier to design, iterate on, and maintain sophisticated workflows without losing structure.
***
### 💬 Global Chat Component Refactor
* **What’s New:** The chat component has been completely overhauled and hoisted up to the home route.
* **User Value:** Previously, the chat was constrained to the context guard view and you wouldn't be able to see it if it was closed. It is now globally accessible across all fronts—including the home route, workflows, and nodes—while preserving its state.
***
### 🗺️ New Guided Onboarding Tour
* **What’s New:** We've introduced a new guided tour tutorial for new users.
* **User Value:** This walkthrough guides you cleanly through the core skill flow, ensuring you can discover and execute your first workflow with ease.
# Version 0.6.2
Source: https://docs.deepvista.ai/version/0-6-2
June 17, 2026
We've rolled out several exciting updates this week to give you more visual flexibility, better tracking for your automations, and a smoother way to manage your account features. Here is a high-level look at what’s new in **Version 0.6.2.**
***
### 🎨 Visual & User Experience Enhancements\*\*
* **Flexible Workflow Display:** We’ve completely rebuilt our workflow renderer. This major layout upgrade gives us the flexibility to design much cleaner, more dynamic visual interfaces for you moving forward.
![Animation]()
* **Real-Time Parallel Run Tracking:** You can now monitor multiple workflow runs simultaneously. New page indicators let you easily click through different runs to instantly view specific run data and execution details.
![Animation2]()
***
### ⚡ Smart Automations & Flywheels\*\*
* **Instant Web Forms for Workflows:** For any automation workflow you create, DeepVista now automatically generates a clean, shareable web form. When someone fills it out, it immediately triggers your corresponding workflow in real time.
![Animation3]()
* **Live Workflow Progress Indicators:** When a workflow runs, you can now watch it execute live. An interactive visual indicator moves through each step of your process as your data is handled.
![Animation6]()
***
### 💳 Premium Features & Billing Integration\*\*
Our official pricing and credits system is now fully live in production. You can seamlessly top up your account balance directly through the app portal to keep your ongoing automations running smoothly without interruption.
* **Starter Top-Up:** \$20 for 2,000 credits
* **Growth Top-Up:** \$100 for 5,000 credits
# Version 0.6.3
Source: https://docs.deepvista.ai/version/0-6-3
June 23, 2026
We’ve rolled out a set of user experience enhancements and automation tools this week to help you manage your workflows and data with total precision. From grouping your entire workspace around specific projects to fully automated browser assistants, here is a look at what we shipped.
***
### **📂 A Smarter, Project-Scoped Workspace**
We have fundamentally rearranged how data is organized in DeepVista to make context switching seamless.
* **Project-Scoped Architecture:** Everything you work on—including your workflows, notes, databases, and chat histories—is now strictly tied to its respective project. This ensures your data remains completely organized and isolated.
![Animation 1]()
* **Custom Project Cover Images:** Give your workspace some personality! You can now upload custom images when creating or editing a project to make them instantly recognizable.
![Animation3 1]()
***
### **📊 Base Pages & View Enhancements**
Managing your information at scale is now faster and highly customizable.
* **Interactive Table Views:** The DeepVista Base page has been upgraded to a clean table view layout.
![Animation4]()
***
### **💬 Streamlined Chat & Workspace Navigation**
Conversing with your knowledge base is smoother and more intuitive than ever.
* **Full History Embedded Chats:** Embedded chat interfaces have been updated into a full layout that displays your entire conversation history. Users can seamlessly click through and navigate across individual past chat sessions.
![Animation5]()
* **Tag Filters:** You can now view and assign tags directly from the Contact view, as well as apply tag-based filters across your Notes and Workflows to find what you need instantly.
![Animation6 1]()
# Version 0.6.4
Source: https://docs.deepvista.ai/version/0-6-4
July 1, 2026
Welcome to this week's DeepVista release update! We've been hard at work shipping features designed to make building workflows, managing your data, and creating content faster and more intuitive. Here is a look at what the team built last week.
***
### **✨ Editor & Workflow Enhancements**
We have significantly upgraded the editor and workflow mechanics to eliminate friction and speed up your day-to-day operations.
* **Lightning-Fast AI Editing:** You can now interact with our AI faster than ever. Simply highlight any text in the editor and hit `Cmd + K` (`Ctrl + K` on Windows) to instantly open a quick-edit prompt. You can also use `Cmd + Shift + L` to send an existing contact card directly to the embedded chat.
![Lightning-Fast AI Editing]()
* **Direct Workflow Editing:** Say goodbye to unnecessary clicks. You can now edit your workflows directly in the main view, completely removing the friction of jumping into a separate Markdown window.
![Direct Workflow Editing]()
* **Revamped Workflow UI:** We've reorganized the workflow settings into a clean, new three-tab interface (Vista Base, Webhooks, and Input Forms). This makes configuring your inputs and managing connections much more interactive and straightforward.
![Revamped Workflow UI]()
***
### **📊 Better Data Views in Vista Base**
We've completely overhauled how you interact with datasets to give you full control over your layout and analysis.
* **Customizable Tables:** Your data, your way. We’ve upgraded the Vista Base table displays to support column resizing and drag-and-drop reordering, making it easier to view what matters most to you.
![Customizable Tables]()
* **Advanced Filtering:** We've introduced robust multi-filter support for tables. You can now stack multiple filters on your datasets to find specific users or records in seconds.
![Advanced Filtering]()
# Version 0.6.5
Source: https://docs.deepvista.ai/version/0-6-5
July 15, 2026
We've been busy shipping some massive upgrades over the last two weeks to make your experience smoother and vastly more powerful. From a fresh face for our landing and discover pages to turning your own hardware into a personal AI agent, here is what actually built:
***
### **🎨 A Fresh New Look & Discover Experience**
We have redesigned major entry points of the app to make finding what you need effortless.
* **Redesigned Landing Page:** A streamlined layout built to showcase the product's capabilities cleanly.
![Lightning-Fast AI Editing]()
* **New Discover Page:** Featuring a brand new hero section and a prominent search bar so you can instantly find relevant skills and workflows.
![Direct Workflow Editing]()
### **🔒 Seamless Collaboration with Context Card Locking**
When multiple team members are working together, keeping data safe is essential.
* **Edit Locking:** We have added a "lock" system for context cards. If you open a card that someone else is currently editing, a banner will notify you that the card is locked.
* **Take Over Feature:** If you need to make changes immediately, you can choose to "Take Over" editing, which instantly updates the banner on the other user's screen. This works across all workflows, nodes, and context cards.
![Customizable Tables]()
* **Advanced Filtering:** We've introduced robust multi-filter support for tables. You can now stack multiple filters on your datasets to find specific users or records in seconds.
***
### **💻 Turn Your Local Machine into a DeepVista Agent**
We have unlocked a powerful new way to execute tasks directly on your local hardware or remote cloud servers using the brand-new DeepVista CLI.
* **Local Task Delegation:** By running a simple background command on your machine (Mac, Windows, or Linux), your hardware will poll our server's task queue.
* **Run Complex Workflows Remotely:** You can prompt the DeepVista agent from your phone while on the go, and it will securely dispatch and execute complex scripts or processes (like posting directly to social media) on your active machine back home.
![Customizable Tables]()
![Customizable Tables]()
# Version 0.6.6
Source: https://docs.deepvista.ai/version/0-6-6
July 20, 2026
Welcome to this week's DeepVista release update! This week, we shipped a series of upgrades designed to give you smarter workspace organization, fairer team credit sharing, and dynamic AI model routing that just works.
***
## What We Shipped This Week
### 🗂️ Smarter Workspace Context & Filters
* **Filter by Attributes:** Quickly narrow down notes, workflows, or context cards in VistaBase using targeted metadata attributes.
![Lightning-Fast AI Editing]()
![Lightning-Fast AI Editing]()
* **Unified Workspace Folders:** Notes and workflow folders now live in a single unified hierarchy, making it effortless to organize mixed context cards together.
![Lightning-Fast AI Editing]()
![Lightning-Fast AI Editing]()
* **Artifacts & Type Correction:** We’ve reserved **Notes** exclusively for human-written context and created a dedicated **Artifacts** card type for AI-generated memories and code snippets. If an AI card is ever misclassified, you can manually correct its type in the card options.
![Lightning-Fast AI Editing]()
![Lightning-Fast AI Editing]()
***
### 💳 Fairer Credit Allocation
* **Project-Level Credit Usage:** Workflow executions now deduct credits directly from the **project owner’s balance**, rather than penalizing individual team members who trigger the run.
![Filter by Atrributes]()
***
### 🤖 Intelligent Model Routing & Generation Metrics
* **Automatic Model Selection:** DeepVista now dynamically routes your prompts to the optimal model. Simple chat queries automatically hit lightweight, ultra-fast models like **GLM** or **Kimi**, while heavy reasoning and task-oriented jobs route straight to powerhouses like **Claude**.
![Lightning-Fast AI Editing]()
![Lightning-Fast AI Editing]()
# Version 0.6.7
Source: https://docs.deepvista.ai/version/0-6-7
July 27, 2026
This week we unlock 4 light workflows so you can run automated playbooks without keeping your laptop open or losing track of background work.
**Highlights**
* **Run 24/7 background workflows without keeping your laptop open.** DeepVista now hosts and executes background tasks on cloud machines with 1-click browser terminal access.
* **Upload files and talk to any content type in chat, with password protection.** Upload documents, audio, and attachments directly into chat, with a 1-click private mode to pass API keys and passwords safely.
* **Never miss a completed task with a unified notification inbox.** Replaced scattered, hard-to-follow workspace alerts with one central notification feed showing what needs your attention.
* **Connect AI agents directly to product docs and LinkedIn.** Connect live Mintlify docs and LinkedIn accounts directly to your project so agents can look up setup guides and manage outreach automatically.
***
## Workflows enhanced in our library
Feature updates like MCP connectors, notification alerts, and folder organization are building blocks that enhance real, end-to-end workflows in the DeepVista library. Here are the specific workflows that were upgraded this week:
Connect Gmail and ask the agent to run any task you'd normally do by hand.
Set up a CRM tracker and let DeepVista keep pipeline stages up to date from your conversations.
Research, score, and enrich high-fit prospects, then stage personalized outreach.
Capture and qualify new accounts the moment they reach out to you.
***
## What we shipped this week
### 🔔 Notification Center
Never miss a background update with the new centralized notification inbox that alerts you the moment tasks finish or fail.
![Notification Center]()
### 🧾 Comment-Based Task Logs
Keep your documents clean by automatically moving background task execution logs into expandable comments at the bottom of cards.
![Comment-Based Task Logs]()
### 🔌 Project-Level MCP Servers
Connect custom documentation and LinkedIn directly to your projects so AI agents can query live tools and data natively.
![Project-Level MCP Servers]()
### 🕶️ Mark as Sensitive Mode
Protect private credentials by toggling sensitive mode in chat to execute prompts without saving passwords to database logs.
![Mark as Sensitive Mode]()
### 🗂️ Workspace Workflow Folder Organization
Organize your growing library of automated playbooks into structured project folders for instant navigation.
![Workspace Workflow Folder Organization]()
***
## Ready to try a light workflow?
Pick one of the tutorials above to deploy your first browser-native playbook in under 2 minutes. Try it out today and share your feedback with us in the community channel!
# Version 0.6.8
Source: https://docs.deepvista.ai/version/0-6-8
August 6, 2026
Collaborating with team members and agents is getting smarter on DeepVista.
**Highlights**
* **Organize your project with Workbenches.** You can now group workflows, context cards, and scheduled jobs, and find them easily on the homepage.
* **Transfer your understanding of relationships between entities to your agents.** In your prompt, mention a person card, a note on a customer call, and a workflow to create connections for your agent.
* **Research smarter by chatting.** You can now create an intelligent table card that can populate any information you want just by chatting with DeepVista.
* **Turn your thinking process into executable workflows with one click.** Drop in a screenshot or any unstructured thought, and watch DeepVista convert it into a workflow ready to execute.
***
## Try these on DeepVista
### 1. Capture a Quick Note and drop it in a Workbench.
Organize notes and assets instantly by dragging quick notes into dedicated project Workbenches.
![Organize your project with Workbenches]()
### 2. Mention @ to find a context card.
Access relevant team notes, people, and resources instantly by typing `@` anywhere in your prompt.
![Mention @ to find a context card]()
### 3. Watch DeepVista populate a new column in your table card.
Generate and populate new data columns automatically through inline chat prompts inside VistaBase tables.
![Watch DeepVista populate a new column in your table card]()
### 4. Pick a chat and convert your thinking process into a workflow.
Turn past chat sessions and brainstorming turns into executable team playbooks with a single click.
![Pick a chat and convert your thinking process into a workflow]()
## Check out the most popular workflow among GTM leaders
By the end of this tutorial, you will close one continuous loop of automated playbooks to acquire, engage, and retain your customer.
Set up a CRM tracker and let DeepVista keep pipeline stages and next steps up to date from your conversations.
# Version 0.6.9
Source: https://docs.deepvista.ai/version/0-6-9
**From this moment, you can unlock more magic on DeepVista, just by using a quick enable button and chatting!**
We've expanded DeepVista's connectivity engine to integrate with third-party applications via Composio, run real-time deep research with Exa Agent, and add interactive chat decision controls to conversations.
**Also, collaborating with your team members remotely & organizing context across projects are getting smarter here [aga](/version/0-6-8)in.**
You can now:
* Co-edit a doc with multiple team members in real time.
* Ask the agent to drop your recent output or any ongoing work process (e.g., a note, a workflow, or any context card) into a workbench and find them easily later.
**Try out a new workflow we unlocked last week:**
Auto-reply to new LinkedIn messages triggered by a webhook using a Unipile account.
## Want to dive in the latest changes?
**Technically, you can:**
* **Connect external software natively with Composio MCP & OAuth2:** Securely pass managed credentials and grant agents live access to third-party APIs without manual key configuration.
* **Batch-find lead emails with Exa Agent:** Run live web queries directly inside agent workflows for up-to-date market intelligence and company research.
* **Guide your agent to act more precisely in chat:** Make choices via structured checkbox widgets (`` blocks) without typing out manual instructions.
* **Organize projects easily with agent-created Workbenches:** Let agents automatically create custom Workbenches and pin your favorites for instant access.
***
## Try these on DeepVista
#### 1. Composio Managed MCP & Exa Web Search
Connect live APIs and query real-time web content natively inside your agent workflows.
**How to use it:**
* To enable Composio, navigate to **User → Composio**.
![Screen Recording 2026-08-11 at 6.19.26 PM_3-25s.gif]()
* To enable Exa Agent, navigate to **Experimental → Enable Deep Research.**
![Screen Recording 2026-08-11 at 6.26.12 PM_2-12s.gif]()
#### 2. \ Blocks That Present Questions & Options Inside Chat
Prevent your agent from guessing missing context or stopping mid-workflow to ask open-ended questions.
* **How to use it:** When an agent presents options during a run, click your preferred choices directly on the interactive card to resume execution.
![Screen Recording 2026-08-11 at 6.33.36 PM_27-60s_3x.gif]()
#### 3. Agent Workbench Organization
Keep growing projects structured automatically without requiring manual folder creation and navigation.
* **How to use it:** Ask your agent to organize outputs into a new Workbench.
![Screen Recording 2026-08-11 at 7.08.53 PM_0-5s_and_2m55-3m07s.gif]()
#### 4. Card Lineage Tracing & Attribution
Trace which chat session or workflow execution generated every context card in your project, so you can audit team and multi-agent runs.
* **How to use it:** Open any context card details panel to view its connected source chat sessions and workflow executions.
![Screen Recording 2026-08-11 at 7.26.26 PM_4-10s.gif]()
***
## View our Light Workflow Gallery:
Set up a CRM tracker and let DeepVista keep pipeline stages and next steps up to date from your conversations.
Auto-reply to new LinkedIn messages triggered by a webhook using a Unipile account.
# Version 0.7.0
Source: https://docs.deepvista.ai/version/0-7-0
August 20, 2026
Drop messy call notes, LinkedIn screenshots, and campaign ideas into chat, and DeepVista builds a clean, auto-updating lead list — no manual formatting.
Version 0.7.0 overhauls **Trackers**, DeepVista's live data lists for running your CRM and social campaigns. Ask in plain English to slice, sort, and reorganize your pipeline without touching the underlying records, track the full history of every deal, and export a ready-to-share spreadsheet in one click.
**Highlights**
* **Clean data separation, no ghost rows.** Meeting notes, call transcripts, and campaign playbooks stay linked in the background instead of creating blank rows in your list.
* **Natural-language custom views.** Ask DeepVista to filter high-fit leads, sort campaign posts, or reorder columns. It updates your display view instantly without modifying or deleting the underlying records.
* **1-click spreadsheet export.** Download any CRM or campaign tracker as an Excel-compatible CSV from the tracker options menu.
* **Full version history.** Every row added, removed, or updated shows up in one unified timeline.
* **Smart import and a cleaner grid.** Paste multi-cell data from Excel or Google Sheets without broken formatting. Column borders and draggable resize handles make dense trackers easier to scan.
Build a CRM tracker from your ICP, keep it clean of ghost rows, and update it by pasting in call notes.
Schedule a campaign in a tracker, generate tracking links, and route inbound leads straight into your CRM.
***
## What we shipped this week
### Clean data separation (no more ghost rows)
Trackers now separate actual data records from linked reference context.
* **Dedicated row architecture:** attaching background research notes or a campaign playbook to a tracker no longer creates a blank "ghost" row. Trackers isolate real data items from reference links.
* **Connected background context:** call notes, customer emails, ICP briefs, and campaign workflows stay attached to your tracker in the background, fully accessible to the AI without cluttering your data grid.
* **Interactive card rows:** every row is still a full context card. Click any contact or campaign post to open its profile, past communications, and associated tasks.
![Attaching background research to a tracker row no longer creates a ghost row]()
### Non-destructive AI views
* **Prompt-driven filtering and sorting:** tell DeepVista "show only high-fit inbound leads from this week's social campaign" or "sort CRM contacts by outreach date and hide internal notes."
* **Non-destructive view layer:** view changes touch only display rules — filters, sort order, visible columns. Your context cards and campaign records stay untouched.
* **Persistent saved layouts:** custom views save automatically, so you and your team return to the same column setup every time.
![Filtering and sorting a tracker with a plain-English prompt]()
### Versioned rows and a unified history
* **Versioned row additions and removals:** trackers record the exact revision when a row is added, completed, or removed.
* **Unified changelog:** row edits and tracker setting changes merge into one chronological activity history.
![A tracker's unified changelog of row and setting changes]()
### Visual grid polish
* **Visible column borders:** grid lines make dense customer lists and multi-day campaign schedules easier to scan.
* **Draggable column resize handles:** adjust column widths to fit long company names, LinkedIn URLs, and status tags.
![Column borders and draggable resize handles in a tracker grid]()
***
## Try these on DeepVista
#### 1. Build an intelligent CRM tracker
Prompt DeepVista with your target customer profile:
```text theme={null}
Research 10 target companies matching our ICP and create a CRM tracker with columns for Company, Contact, LinkedIn URL, and Outreach Status.
```
DeepVista builds the tracker and populates verified records. Paste in call notes or screenshots and ask DeepVista to update the matching row.
#### 2. Launch a 10-day social media campaign
Give DeepVista a tutorial, landing page, or release note and prompt:
```text theme={null}
Research this content and propose 10 social copies targeting our ICPs with lead capture forms linked to our CRM tracker.
```
DeepVista schedules the campaign in a tracker, generates unique tracking links, and routes inbound form submissions straight into your CRM.
#### 3. Filter your pipeline with plain English
Open your CRM tracker and prompt:
```text theme={null}
Filter this tracker to show only leads who received an outreach email, and sort them by the last touchpoint date.
```
DeepVista updates your saved view immediately and leaves the original records untouched.
***
## Start building your own Trackers
Follow the step-by-step guides to set up automated [Customer Research & Tracking](/tutorials/customer-research-and-tracking) for your pipeline, or launch a multi-day [Social Media Campaign](/tutorials/social-media-campaign) with built-in lead capture.
# Version 0.7.1
Source: https://docs.deepvista.ai/version/0-7-1
Research to outreach, in one chat: Find niche communities, pull customer leads into a database, and draft follow-up email sequences all in the same thread.
#### **1. Start with database, not workflows**.
Don't build complex workflows from scratch.
Now you can generate a **database** (like target leads or user interview lists) with a single prompt, edit it, and only automate it once you like the results.
![Screen Recording 5s With Crm Image 1]()
Learn more about building your database [here](https://docs.deepvista.ai/tutorials/customer-research-and-tracking).
#### **2. Drop long meeting audio directly into chat**.
You can now upload long audio files straight into chat.
DeepVista listens and extracts them directly with no separate transcription tool needed.
#### **3. Instant Command-K search**.
Press `⌘K` from anywhere in the app to find any note, database, or workflow instantly.
#### **4. Chats file themselves into Workbenches**.
When you chat about a project or note inside a Workbench, the conversation automatically saves into that Workbench.
#### **5. Pin notes on workflow charts**.
Pin multiple step popovers onto your visual workflow canvas like sticky notes so you can view the whole plan at once.
![Pin multiple workflow step popovers onto the canvas]()
# Version 0.7.2
Source: https://docs.deepvista.ai/version/0-7-2
New ways to guide the AI, organize contacts across your databases, and onboard new projects, plus a smoother chat-to-asset UI.
August 31, 2026
#### **1. Leave instant feedback on chat responses**
Rate and leave notes directly under any message the agent generates.
If an answer misses the mark or needs adjustment, submit a quick score and comment right in the thread. This feedback helps us spot patterns and tune agent behavior faster.
![Rating a chat response with a score and optional comment]()
#### **2. Aggregate people across workbench databases**
Workbenches now roll up people across all your databases into one master roster, instead of making you click through separate lead lists or search outputs.
Every outreach search or contact import you run adds to that same unified view.
![Browsing people and records aggregated across a workbench's databases]()
#### **3. Redesigned project onboarding flow**
Starting a new project is now faster with a guided setup.
When you create a project, the flow walks you through setting up your initial workbenches, workflows, and goals so you can start working right away.
![Picking a starting point when setting up a new project]()
#### **4. Inspect generated cards without losing your chat flow**
When the AI creates a note, database, or document mid-conversation, it now opens automatically in the right side panel.
You can inspect new outputs right away without clicking around or losing your place in the chat.
![A generated card opening automatically in the side panel during a chat]()
# Version 0.7.3
Source: https://docs.deepvista.ai/version/0-7-3
Connect your LinkedIn account to DeepVista, watch your agent work from chat history, jump to results and save drafts faster with your keyboard, roll every workbench up into one parent database, and save versions whenever you want.
September 5, 2026
#### **1. Connect your LinkedIn account to DeepVista**
DeepVista now supports LinkedIn connector. Go to **Settings → User → Connectors** and connect your LinkedIn account.
![The Connectors settings page with LinkedIn available to connect]()
#### **2. Watch your agent work from chat history**
The floating chat now shows background actions directly in each thread's preview.
Glance at a thread and see whether the agent is searching the web, updating a card, or running a task, before you even open it.
![A chat thread preview showing an agent's live background actions]()
#### **3. Jump straight to a result with ⌘K, and save drafts with ⌘S**
Global search now supports full keyboard navigation. Press `⌘K` (or `Ctrl K`) to open search, then use the Up and Down arrow keys to highlight and open notes, databases, and workflows without reaching for your mouse.
![Navigating global search results with arrow keys]()
Pressing `⌘S` (`Ctrl S`) now saves your active document or note draft immediately, instead of waiting on autosave.
#### **4. Every workbench rolls up into one parent database**
Every workbench now has a parent database with everyone you've already researched, one summary across all your work.
Ask something like "find customers I need to follow up with today," and DeepVista creates a child database under the parent, a focused list for that question that still rolls up into the summary.
New workbenches get this automatically. Existing workbenches will be reorganized the same way.
![The parent database rolling up its child databases]()
#### **5. Save a version whenever you want**
Notes and context cards now have a "name current version" button. Snapshot your work at any time so that you never lose it.
![Output]()
# Version 0.7.4
Source: https://docs.deepvista.ai/version/0-7-4
Set up a new project in two steps, customize your database in any workbench, and co-edit a note with your DeepVista agent safely.
September 9, 2026
#### **1. Set up a new project in two simple steps**
Creating a project now takes two simple steps instead of one long form. First, name your workbench using ready-made presets instead of a blank field. Then DeepVista opens that workbench and fills in a starting prompt for you automatically. Adding a workbench from the right-hand menu also shows its default database right away.
![Choosing a preset and starting prompt while setting up a new project]()
#### **2. Rename a version by clicking its name**
Click a saved version's name to rename it in place, just like a file in Google Docs. No separate dialog needed.
![Renaming a saved version by clicking its name]()
#### **3.** Customize your database in any workbench
Every workbench keeps one combined database of everything inside it, including nested workbenches. Add or move a database in and it's included right away, no setup needed. You can customize that combined database's own columns, sort order, and views just like any other database.
![Adding a database to a workbench and seeing it join the combined view]()
#### **4. Press ⌘S to name your current version**
⌘S (Ctrl+S) in a card editor now always names your current version. It no longer falls through to the browser's save dialog.
![Pressing Cmd+S in a card editor to name the current version]()
#### **5.** Co-edit a note with your DeepVista agent safely
If you edit a card while an agent is writing to it too, your edit no longer gets overwritten. The agent's write is rejected the moment it detects your change, so it re-reads your latest version and tries again. A card nobody else is touching still saves in a single step.
![Editing a card while an agent writes to it without losing either change]()
#### **6. Check a workflow's schedule and next run at a glance**
Every workflow's list and detail view now shows whether its schedule is enabled and the time of its next run, so you don't have to open it to check.
![Hovering a workflow card to see its schedule status and next run time]()
#### **7. Trust what a backgrounded chat tab tells you**
If you background a chat tab while the agent is still working, the turn no longer looks finished before it is. It stays marked as generating, tool-call steps keep appearing without a reload, and the reply's action buttons show up only once the run actually completes.
# Version 0.7.5
Source: https://docs.deepvista.ai/version/0-7-5
Turn any database into an automated workflow, set up new projects in guided steps, jump from workflow outputs straight to your database, and browse an updated Playbook library.
September 10, 2026
#### **1. Turn any database into an automated workflow**
Your un-automated databases now display an **Add a workflow** button in the toolbar. Clicking it starts a quick, guided chat setup where DeepVista helps you choose what data to track, sources the answers, and keeps your columns populated automatically.
Get started by opening any database and clicking `Add a workflow` in the toolbar.
![Adding a workflow to a database from its toolbar]()
#### **2. Set up new projects in a few guided steps**
Starting a project no longer requires filling out a long form. A quick step-by-step setup guides you through naming your project, choosing an inbound or outbound focus, and opening your first workbench with starter tables and prompts ready to go.
Get started by clicking `+ New Project` on your dashboard.
![Setting up a new project through the guided step-by-step flow]()
#### **3. Jump straight from workflow outputs to your database**
Want to see the records your workflow just produced? In the workflow diagram, click the `Output` node to open the target database directly. No more switching views or searching through your workbench to find your new data.
Try it by opening any workflow and clicking its `Output` node.
![Clicking a workflow's Output node to open its target database]()
#### **4. Open your rollup database automatically**
Workbenches now open directly to your aggregated database view. When you open a workbench to check leads, contacts, or research, your rollup table appears right away so you can get to work without an extra click.
Try it by navigating to any workbench from your sidebar.
![Opening a workbench directly into its rollup database view]()
#### **5. Browse and copy prompts in the updated Playbook library**
Looking for prompt templates? The `/playbook` directory has a clean new layout with prompt cards you can copy in one click, plus quick controls to save prompts and database settings directly to your workbenches.
Get started by visiting `app.deepvista.ai/playbook`.
![Browsing and copying prompt templates in the updated Playbook library]()
#### **6. Real-time status for your background workflow runs**
Keep tabs on background runs without second-guessing. Dispatched workflow runs now update their status live: if a run hits an issue, you will see it marked in red right away. You can also click directly into the run's chat session to review results or see what happened.
Try it in any workflow from the `Runs` tab.
# Version 0.7.6
Source: https://docs.deepvista.ai/version/0-7-6
Get automatic AI summary briefs across your workbenches, jump directly from cards to parent databases, navigate card mentions faster in the editor, copy chat responses with full formatting intact, and pin key table columns.
September 15, 2026
#### **1. Get automatic AI summary briefs across your workbenches**
Opening a workbench now shows an automatic summary brief in the right panel by default. View total card counts, track recent updates, and read suggested next actions for your workflow without clicking through individual cards or calculating metrics by hand.
![Opening a workbench to see its automatic AI summary brief]()
Try it by opening any workbench from your dashboard or sidebar navigation.
#### **2. Jump directly from cards to parent databases**
When viewing a context card that lives inside one or more databases, you can now trace its parent tables immediately. Click the new `Database` button in the card header to open a popover listing every database the card belongs to, complete with direct navigation links.
![Clicking the Database button on a card to jump to its parent databases]()
Try it by opening any person, organization, or note card linked as a database row.
#### **3. Navigate card mentions faster in the editor**
Typing `@` inside any note or card editor to link context cards is now much smoother. Search filtering and arrow-key navigation respond instantly, and typing symbols or punctuation inside your search query no longer closes the mention menu unexpectedly.
![Typing @ in a note editor to search and navigate mentions]()
Try it by typing `@` inside any note or context card to search and link related cards.
#### **4. Copy chat responses with full formatting intact**
Copying assistant replies now preserves complete markdown formatting, including headers, bullet lists, code blocks, and bold emphasis.
![Copying a chat response and pasting it with formatting preserved]()
Try it by clicking the `Copy` icon on any formatted chat response and pasting it into your notes.
#### **5. Pin key table columns**
Pin your primary column, such as Company, Name, or Status, so it stays anchored to the left border while you scroll through long rows of data.
![Pinning a column so it stays anchored while scrolling a database table]()
Try it by opening any database table, clicking a column header menu, and selecting `Pin column`.
# Version 1.0.0
Source: https://docs.deepvista.ai/version/1-0-0
DeepVista is now a unified outbound engine, taking prospects from lead research to sent outreach with a redesigned workbench and closed-loop automation.
September 19, 2026
#### **1. Work from one unified workbench**
Prospecting, campaigns, and research now live in a single three-tab workbench: Tracker, Workflows, and Notes. Manage prospects, run campaigns, and document research without switching between separate tools.
Try it by opening any workbench and moving between the Tracker, Workflows, and Notes tabs.
#### **2. Let closed-loop automation run your pipeline**
New inquiries and prospect lists now trigger qualification, message generation, and tracker syncing automatically. Records update on their own as prospects respond or move through sales stages, so your tracker stays current without manual updates.
Try it by adding a new prospect list or inquiry and watching the tracker update as it moves through the pipeline.
#### **3. Get set up with guided onboarding**
New workspaces now follow a four-step setup: define your target customer profile, build your initial prospect database, configure outreach campaigns, and activate dispatch.
Try it by creating a new workspace and following the onboarding flow from profile to dispatch.
# Version 1.0.1
Source: https://docs.deepvista.ai/version/1-0-1
Find more complete lead profiles for your pipeline, put your daily prospecting and outreach on autopilot, and act on workbench recommendations instantly.
September 22, 2026
#### **1. Get more complete search results for new leads**
Lead discovery now consistently captures essential contact and company details, so every new lead includes a name, role, and LinkedIn URL. Discovered profiles appear in your workbench table with clickable links, so you can read a prospect's role and jump directly to their LinkedIn profile or their company's.
![Running a Lead Discovery workflow to see complete lead profiles with clickable LinkedIn links]()
Try it by creating a new workbench or running a Lead Discovery workflow.
#### **2. Put your prospecting and outreach on autopilot**
Keep your pipeline moving without manual supervision. You can now schedule your workflows, such as finding new leads or sending email sequences, to run automatically on your preferred routine, whether that is daily at 9:00 AM or on a custom cadence.
![Clicking the schedule link next to a workflow toggle to set a run frequency]()
Try it by clicking the schedule link next to any workflow toggle in your workbench.
#### **3. Act on recommended priorities instantly**
Turn workbench recommendations into immediate action. Clicking any action button under Things to do now opens a workspace with the relevant contacts, background cards, and task details already loaded, so you can act without retyping anything or starting from scratch.
![Clicking an action button under Things to do to open a workspace with contacts and task details already loaded]()
Try it by clicking any action button under Things to do on your workbench overview.
# Version 1.0.2
Source: https://docs.deepvista.ai/version/1-0-2
Set up a workbench from a template, keep raw customer context in Notes, repeat proven work with workflows, and track results in the Database.
September 30, 2026
#### **1. Create a workbench for each initiative**
A workbench gives each initiative one home for its context, workflows, and results. Start from a template like **Lead Research & Outreach**, or choose **Skip for now** for a blank canvas.
![Creating a new workbench from a template or a blank canvas]()
Try it by clicking **Create New Workbench** on your workbench page and picking a template or **Skip for now**.
#### **2. Drop raw context into Notes**
Paste in discovery takeaways, interview quotes, objections, and rough thoughts as they are. Your agent searches Notes on its own to find real decision-makers and draft emails that quote actual customer problems.
![Pasting raw call takeaways into the Notes tab of a workbench]()
Try it by pasting call takeaways or user feedback into the **Notes** tab of your workbench.
#### **3. Run or create a workflow to repeat verified work**
Refine your lead criteria and email drafts with your agent first. Once you find the angle that gets replies, turn it into a workflow and repeat it.
![Running a workflow and adding a new one in a workbench]()
Try it by running a workflow in your workbench, or click **Add workflow** to automate steps that already work.
#### **4. Track results in the Database**
The Database records verified leads, email statuses, and booked meetings as your agent finishes tasks, so you can check results in one place.
![Opening the Database tab to review leads, outreach stages, and booked calls]()
Try it by opening the **Database** tab to inspect leads, review outreach stages, and track booked calls.
# Version 1.1.0
Source: https://docs.deepvista.ai/version/1-1-0
DeepVista 1.1.0, built to sharpen your judgment, and find you the right people.
October 13, 2026
DeepVista now helps you find precise leads. Don’t hand over your judgment on who is the right person to an agent.
#### **1. Judge 5 people, and surface the signals you care about**
![Judge 5 people, and surface the signals you care about]()
* Looks past headcount and funding stage, at founder activity, team composition, and recent job postings.
* Your reasoning becomes the agent’s criteria.
* In our tests, one round of scoring made the next batch 40% more accurate.
Try it by asking in the new project, “Find me \[who you’re looking for].” Score the 5 people it shows you, fit or not, and say why.
#### **2. Reach out in batch. Goodbye generic templates.**
![Reach out in batch]()
* Connect first, short intro, before any outreach message.
* Their posts tell you the topic to open with, not a guess.
* Ask the agent why one person replied and another didn’t, and use that to challenge your own assumptions about who’s actually a fit.
Try it by asking in chat, “Draft outreach for these 5 leads.” Treat your agent as a thinking partner: “Why did this one reply and that one didn’t?”
#### **3. One database. Remember every customer and what to do next.**
![One database for every customer]()
* Every touchpoint, call note, and meeting note lands in one place, visible to the whole team.
* Hand a deal to whoever’s booking the call or closing it, and they already have the context.
* Ask the agent who to follow up with, or who to tell about a new update, and it already knows.
Try it by asking in chat, “I have a new update, who should I tell?” or “Log this call, what’s the next step for this person?”