The Agents application is an advanced multi-agent AI system that intelligently routes requests to specialized agents and subgraphs for comprehensive assistance. The system features a compound agent architecture with XML-based routing, code execution capabilities, and multi-step research workflows. The Agents application helps users by:
- Providing intelligent assistance through a unified compound agent system.
- Executing code in secure Daytona sandbox environments.
- Performing comprehensive data science workflows with multi-agent collaboration.
- Generating detailed research reports and educational content.
- Conducting advanced financial analysis with real-time data.
- Automatically routing queries to appropriate specialized subgraphs.
- Supporting voice input for natural interaction.
The basic process of the Agents application is described below.
-
Enhanced agent processing
- User submits a query via text or voice input.
- The compound agent system uses XML-based routing to determine the best approach.
- Queries are processed through the main agent or routed to specialized subgraphs.
-
Intelligent subgraph routing
- The system automatically determines if queries require specialized subgraph processing.
- Available subgraphs include: Financial Analysis, Deep Research, Data Science, and Code Execution.
- Multi-agent collaboration within subgraphs for complex workflows.
-
Tool and data integration
- Dynamic tool loading based on user context and permissions.
- Integration with external APIs, databases, and knowledge sources.
- Secure code execution and file generation in Daytona sandbox.
-
Real-time response generation
- WebSocket-based streaming for real-time updates and agent reasoning.
- Structured responses with metadata for appropriate UI rendering.
- File artifacts (PDF, HTML, images, CSV) automatically processed and displayed.
-
Adaptive user interaction
- Frontend intelligence automatically detects agent behaviors and adapts UI.
- Agent reasoning panel shows real-time thought processes.
- Continuous learning from interactions to improve future responses.
- API Access
- The application provides a REST API for programmatic access to its features such as deep research and data science workflows.
Note: View the Agent Reasoning panel on the right side of the application to see the real-time thought output. The Daytona Sidebar automatically opens when code execution is detected.
Ensure to install the prerequisites.
-
Python 3.11 (exact version required)
-
Redis (via Docker or Homebrew)
# Run Redis with Docker docker run -p 6379:6379 redis/redis-stack:latest# Install Redis with Homebrew on macOS brew install redis brew services start redis
Get the following API keys to setup the Agents application.
- SambaNova API key (required)
- Serper API key for web search (required)
- Exa API key for company data (required)
- Tavily API key for deep research capabilities (required)
- Daytona API key for secure code execution sandbox (required)
- Clerk for authentication (you'll need both publishable and secret keys)
- LangSmith API key for optional usage tracking and monitoring (optional)
Note: The system supports multiple LLM providers including SambaNova's DeepSeek V3, Llama 3.3 70B, Llama Maverick, and DeepSeek R1 models.
You can setup and run the application in two ways: Cloud hosted version or locally hosted version.
This version is hosted on SambaNova Cloud. No need to install dependencies locally.
- Go to the Agents application login page.
- Sign in using Clerk authentication (you will receive an email with login instructions).
- Once you login, go to settings and add the API keys.
- Start using the application to enhance workflows, conduct research, execute code, and gain actionable insights.
Follow the steps below to install the frontend for the Agents application.
Note: For the following commands, go to
/frontend/sales-agent-crew/directory.
-
Install Vue.js dependencies.
yarn install
-
Run a local development environment.
yarn dev
-
Create a production build.
yarn build
Follow the steps below to install the backend for the Agents application.
Note: For the following commands, go to
/backend/directory.
-
Install Python dependencies: Create and activate a virtual environment (for example with venv) and install the project dependencies inside it. Make sure to use Python 3.11.
# Install uv first pip install uv cd backend uv sync uv pip install -e . # activate the virtual environment source .venv/bin/activate
-
Run the application.
uvicorn agents.api.main:app --reload --host 127.0.0.1 --port 8000 --no-access-log
Note: For the frontend environment variables, go to
/frontend/sales-agent-crew/.
- Create a
.envfile with the following variables.VITE_API_URL=/api VITE_WEBSOCKET_URL=ws://localhost:8000 VITE_AUTH0_DOMAIN=your_auth0_domain VITE_AUTH0_CLIENT_ID=your_auth0_client_id VITE_AUTH0_AUDIENCE=your_auth0_audience
Note: For the backend environment variables, go to
/backend/.
-
Create a
.envfile with the following required variables.# Authentication AUTH0_DOMAIN=your-auth0-domain.auth0.com AUTH0_AUDIENCE=your-auth0-api-audience # Core API Keys (can be user-provided or environment-based) SERPER_KEY=your_serper_api_key EXA_KEY=your_exa_api_key # Research and Deep Analysis TAVILY_API_KEY=your_tavily_api_key # Required for Deep Research subgraph TAVILY_API_KEY_1=your_second_tavily_key # Optional: Additional keys for rotation TAVILY_API_KEY_2=your_third_tavily_key # Optional: Additional keys for rotation # Code Execution DAYTONA_API_KEY=your_daytona_api_key # Required for secure code execution sandbox # System Configuration ENABLE_USER_KEYS=true # Set to "false" to use only environment API keys REDIS_MASTER_SALT=your_redis_encryption_salt # For encrypting user data # Optional: Tracking and Monitoring LANGSMITH_API_KEY=your_langsmith_api_key # Optional for usage tracking and monitoring # Optional: MLflow Integration MLFLOW_TRACKING_ENABLED=false # Set to "true" to enable MLflow tracking MLFLOW_TRACKING_URI=your_mlflow_uri # Required if MLflow is enabled # Optional: Usage tracking LANGTRACE_API_KEY=your_langtrace_api_key # Optional for usage tracking
-
Start the FastAPI backend server.
# From the project root cd backend uvicorn agents.api.main:app --reload --host 127.0.0.1 --port 8000 --no-access-log
-
Start the Vue.js frontend development server.
# From the project root cd frontend/sales-agent-crew/ yarn dev
-
Open your browser and navigate to:
http://localhost:5174/
You can access the settings modal to configure the API keys mentioned in the prerequisites section. The system supports both user-provided API keys and environment-based configuration.
- Sign up for a Clerk account at clerk.com.
- Create a new application in the Clerk dashboard.
- Get your publishable key and secret key.
- Configure your JWT issuer URL.
- Add these values to your environment variables as shown above.
If you want to track usage and monitor the application's performance:
- Sign up for a LangTrace account
- Add your LangTrace API key to the backend
.envfile - The application will automatically log traces (disabled by default)
The system is built on a compound agent architecture with intelligent routing and specialized subgraphs:
- EnhancedConfigurableAgent: Main orchestrator with XML-based routing
- XML Agent Executor: Decision-making engine that routes between tools and subgraphs
- Dynamic Tool Loading: User-specific and static tools with caching
- WebSocket Streaming: Real-time execution updates and agent reasoning
- Financial Analysis: Comprehensive financial reporting with crew-based analysis
- Deep Research: Multi-step research workflows with user feedback
- Data Science: End-to-end data science workflows with multiple specialized agents
- Code Execution: Secure Daytona sandbox for code execution and file generation
This application is built with:
- Vue 3 + Composition API with intelligent UI adaptation
- Vite
- TailwindCSS
- Clerk for authentication
- LangGraph for agent workflows
- FastAPI backend with Redis caching
- WebSocket for real-time communication
The stack is designed to offer high-performance and scalability for both frontend and backend needs. See the frontend and backend technology stack listed in the table below.
| Category | Technologies used |
|---|---|
| Frontend |
|
| Backend |
|
This section describes the agents and feature capabilities of the application.
The core agent system provides:
- Intelligent routing: XML-based decision making for optimal tool and subgraph selection.
- Multi-LLM support: SambaNova (DeepSeek V3, Llama 3.3 70B, Llama Maverick), and other Models powered by SambaNova.
- Dynamic tool loading: User-specific tools with 5-minute caching and graceful fallbacks.
- Real-time streaming: WebSocket-based execution updates with agent reasoning.
- Secure execution: All code execution happens in isolated Daytona sandbox environments.
The General assistant agent helps with:
- Answering basic questions and queries.
- Providing explanations and clarifications.
- Offering technical support.
- Assisting with general research tasks.
- Quick factual information about companies, products, and current events.
Example queries for general assistance are listed below.
- "What's the difference between supervised and unsupervised learning?"
- "Can you explain how REST APIs work?"
- "What are the best practices for data visualization?"
- "How do I optimize database queries?"
- "What is Tesla's current stock price?"
- "What's the latest news on Apple?"
The application uses the Daytona Code Sandbox and Data Science Subgraph for:
- Secure code execution: Python code runs in isolated Daytona sandbox environments.
- File generation: Automatic creation and display of PDFs, HTML, images, CSV files.
- Data science workflows: Multi-agent collaboration for complex data analysis projects.
- Machine learning: Model development, predictive analytics, statistical modeling.
- Data visualization: Automatic chart and graph generation.
- Hypothesis testing: Scientific approach to data analysis with validation.
Example queries for code execution and data science are listed below.
- "Create a machine learning model to predict customer churn using this dataset"
- "Generate a Python script to analyze sales trends and create visualizations"
- "Build a statistical model to analyze the relationship between variables"
- "Create a data cleaning pipeline for this CSV file"
- "Develop a predictive analytics dashboard with interactive charts"
- "Perform hypothesis testing on this experimental data"
For research queries, the application uses the Deep Research Subgraph to:
- Generate comprehensive multi-perspective research reports.
- Create structured educational content with citations.
- Conduct multi-step research workflows with user feedback.
- Provide in-depth analysis on complex topics.
- Include relevant sources and academic references.
Example queries for research and content generation are listed below.
- "Generate a comprehensive report on quantum computing applications in cryptography"
- "Create an in-depth analysis of CRISPR gene editing in modern medicine"
- "Research the relationship between AI and neuromorphic computing with sources"
- "Provide a thorough investigation of blockchain's impact on supply chain management"
- "Analyze the latest developments in fusion energy research with academic citations"
- "Create a detailed market research report on the EV industry trends"
For financial queries, the application uses the Financial Analysis Subgraph to:
- Analyze company financial performance with comprehensive reporting.
- Track market trends and competitive positioning.
- Evaluate stock performance and valuation metrics.
- Generate investment insights and risk assessments.
- Monitor industry-specific metrics and comparisons.
- Provide real-time financial data and analysis.
Example queries for financial analysis and market research are listed below.
- "Provide a comprehensive financial analysis of Tesla including competitors and risk assessment"
- "Analyze the semiconductor industry performance this quarter with market trends"
- "Compare cloud revenue growth between Microsoft Azure and AWS with technical analysis"
- "Evaluate Apple's financial health considering recent product launches and market position"
- "Create a detailed investment report on major EV manufacturers with risk analysis"
- "Analyze the fintech industry trends and top performers with financial metrics"
The application includes several intelligent automation features:
- Daytona sidebar: Automatically opens when code execution is detected
- Agent type detection: Routes responses to appropriate UI components
- File artifact handling: Inline preview for images, PDFs, HTML, CSV files
- Real-time updates: Live execution logs and status tracking
- XML-based decisions: Sophisticated routing between tools and subgraphs
- Context awareness: System understands query intent and complexity
- Subgraph selection: Automatic determination of best workflow for the task
- Tool orchestration: Dynamic loading and execution of appropriate tools
The application allows you to make queries using audio input. Simply click the microphone icon to start speaking. It also offers:
- Automatic speech-to-text transcription
- Hands-free operation for convenience
Additional features of the application are listed below.
- 🔐 Secure API key management – Encrypted storage with user-specific keys
- 📜 Chat history tracking – Persistent conversation storage with Redis
- 📥 Results export functionality – Download generated files and reports
- 🔄 Real-time agent reasoning – Live thought process display
- 🛡️ Secure code execution – Isolated Daytona sandbox environments
- 📊 Multi-format file support – PDF, HTML, CSV, images with inline preview
- 💹 Real-time financial data – Live market data and analysis
- 🤖 Multi-agent collaboration – Specialized agents working together
- ⚡ WebSocket streaming – Real-time updates and responsive UI
-
Configure API keys
- Open settings
- Enter your API keys (SambaNova, Serper, Exa, Tavily, Daytona)
- Keys are securely encrypted and stored per user
-
Start using the system
- Type your query or use voice input
- System automatically determines the best approach (main agent vs. specialized subgraphs)
- Watch real-time agent reasoning in the sidebar
-
Code execution and data science
- Upload datasets or ask for code generation
- Daytona sidebar automatically opens for code execution
- Generated files (PDFs, charts, data) appear with inline preview
-
View and export results
- Research reports displayed as structured documents
- Financial analysis shown with charts and metrics
- Export functionality available for all generated content
- Save important conversations and artifacts
- Fork the repository
- Create your feature branch
- Commit your changes
- Push to the branch
- Create a new pull request