# Toma — full content > Toma builds AI Coworkers for automotive enterprises. Answer every call, work every lead, book every appointment. Production safeguards included. This file aggregates the full markdown content of every public Toma page so generative engines can quote canonical answers. Source of truth: https://www.toma.com. ## Blog ### Toma is now ISO 27001 certified _Source: https://www.toma.com/blog/iso-27001-certification_ _By Anthony_ Dealerships hand Toma some of their most sensitive data: customer names, phone numbers, service history, and a recording of every call. Protecting it is the job behind the job. Toma is now certified to ISO/IEC 27001:2022, the international standard for information security. An independent auditor, Prescient Security, reviewed how we manage risk, control access, and protect data, and confirmed we meet the standard. It joins our SOC 2 Type 2 report and our work to comply with GDPR. ## What ISO 27001 actually checks ISO 27001 is not a one-time box to tick. It certifies that a company runs a working information security management system: the policies and controls for handling risk, access, vendors, and incidents, with evidence that they operate every day. An outside auditor tests that evidence before granting the certificate, then again each year to keep it. Our audit ran in two stages across April and May 2026. The auditor found no deviations and recommended Toma for certification. ## How we protect your data A certificate means little without the controls behind it. Here is what we do. **Encryption.** Customer data is encrypted at rest with AES-256 and in transit with TLS 1.2 or higher. That covers call audio moving across telephony networks, not only our APIs. **Access.** Every person and every service gets the minimum access the job needs, and nothing more. Multi-factor authentication is required for anything that touches production or customer data, and we don't allow shared accounts. **Monitoring.** We watch production around the clock with automated alerting, and a security alert puts an on-duty engineer on it right away. Security events are logged and kept for 5 years, so we can reconstruct what happened if we ever need to. ## Where your data lives Toma runs entirely on Amazon Web Services in US data centers. Access to production systems from outside the US is prohibited. Each customer's data is isolated from every other customer's. Staff at one dealership can see their own customers and no one else's. Critical systems run across multiple availability zones, and backups are encrypted and stored separately, so an outage in one place doesn't take your data with it. ## We don't train models on your data Your calls and customer records are yours. We do not use them to train models, ours or anyone else's. Our contracts with the AI, speech-to-text, and text-to-speech providers behind Toma bar them from keeping or training on your data. You sign one agreement, with Toma, and we stand behind every vendor in the chain. We're also now working toward ISO 42001, the standard for managing AI systems responsibly. More on that when it's done. ## Get the report Customers and prospects can request our ISO 27001 certificate, SOC 2 Type 2 report, and penetration test results under NDA through our trust center at [trust.toma.com](https://trust.toma.com). If you're evaluating Toma, that's where your security and procurement teams should start. ## FAQ **Is my data encrypted?** Yes. At rest with AES-256, and in transit with TLS 1.2 or higher, including call audio. **Where is my data stored?** On AWS, in US data centers. Access from outside the US is prohibited. **Do you use my data to train AI models?** No. We don't train on customer data, and our vendor contracts prohibit it too. **Can I delete my data?** Yes. Email [support@toma.com](mailto:support@toma.com) and we delete everything we're not legally required to keep, within 30 days. --- ### How Toma handles your data under GDPR _Source: https://www.toma.com/blog/gdpr-compliance_ _By Anthony_ When a dealership uses Toma, we process personal data on its behalf: a caller's name, their phone number, what they asked for, and the recording of the call. The EU's General Data Protection Regulation sets the rules for handling that kind of data, and Toma is built to follow them. Most of our customers are US dealerships. The principles behind GDPR are good practice anywhere: collect less, protect what you hold, and let people control their own data. We apply them across the board. ## What GDPR asks of us Two ideas sit at its core. Collect only the data you need for a clear purpose. Give people real control over the data you hold, including the right to see it, correct it, and have it deleted. Both shape how Toma is built. ## How it works at Toma **We collect the minimum.** Toma takes only what the job needs: contact details, appointment information from your dealer management system, and call recordings and transcripts. Nothing more. **One contract, one processor.** You sign a Master Service Agreement and a Data Processing Addendum with Toma, and that's it. We act as the single processor of record. The AI vendors behind Toma are bound by our terms, including a ban on keeping or training on your data, so you never have to manage them yourself. **We keep it only as long as needed.** Customer data lives for the length of our relationship. If an account closes, we hold the data for 30 days in case you come back, then delete it, unless the law requires us to keep it longer. **It's protected the whole time.** Data is encrypted at rest and in transit, isolated per customer, and stored on AWS in US data centers. The same controls that earned our ISO 27001 certificate and SOC 2 Type 2 report apply here. ## Your data, your rights If someone whose data we process wants to see it or have it removed, we honor that. Email [support@toma.com](mailto:support@toma.com) and we delete everything we have no legal reason to keep, within 30 days. ## Get our DPA Our Data Processing Addendum and security reports are available through our trust center at [trust.toma.com](https://trust.toma.com). Your privacy and procurement teams can review them before you sign. --- ### Toma IQ: The AI that actually learns how your dealership operates _Source: https://www.toma.com/blog/toma-iq-the-ai-that-actually-learns-how-your-dealership-operates_ _By Chris_ Every AI vendor says their system "gets better over time." Here's what that actually means, and why Toma IQ is different. Voice AI can outperform humans on service calls until edge cases emerge. The Pied Piper 2025 Service Telephone Effectiveness Study examined over 2,100 dealerships and discovered AI handling end-to-end calls scores 72, eight points above the dealer group average. When transferring to humans, that same AI drops to 50, falling 14 points below average and 22 points below its standalone performance. The technology itself isn't the problem; handling exceptions is. Most dealership AI lacks knowledge about when to escalate, who to route calls toward, or how to maintain customer engagement during resolution. The system was never taught how that specific dealership operates. Critically, failed edge cases repeat weekly because the AI learned nothing from the failure. ## Why "AI that gets better over time" is only half the story Most AI vendors speak truthfully but incompletely. They rely on global model updates from foundational model companies, real and powerful improvements that reduce hallucinations and improve intent recognition. However, global updates cannot know that F-150 recall customers need two-week scheduling minimums or that fleet account mentions warrant commercial team routing. Those details come exclusively from your calls, the workflows your team developed, the edge cases your managers solved, and the preferences your service director embedded into operations. The genuine gap in dealership AI isn't the underlying model; it's the learning loop. ## Introducing Toma IQ Toma IQ operates as an intelligence layer using reinforcement learning with human feedback (RLHF), the technique powering the most advanced AI systems globally, now applied to dealership operations specifically. Rather than improving through generic training data, the AI learns from actual outcomes in its specific environment, guided by human judgment. Successful scenarios are repeated; when humans intervene and handle situations differently, the system learns why that approach worked better. Toma's founding team built careers on this technology at Scale AI, Uber, and Amazon before applying it to automotive. Toma IQ represents one of the earliest dealership AI products explicitly integrating human feedback into how agents learn real-world workflows, policies, and edge cases specific to each dealership location. ## How Toma IQ works in practice Toma IQ executes three continuous background functions: - It analyzes your calls. Every call receives review for patterns: scenarios involving specific human intervention, recurring edge cases, and situations where particular responses consistently delivered superior outcomes. - It generates plain-language policy recommendations. When codifiable patterns emerge, Toma IQ drafts specific, actionable recommendations your AI Coworker can adopt: plain-English policies your service manager can read and approve or reject. - It puts you in full control. Every recommendation lands in your My Policies hub, and nothing changes until a manager approves it. One click accepts. One click rejects. Every change logs, and every policy reverses at any time. A sample recommendation: "When a customer asks about loaner vehicle availability and mentions needing it for more than five days, offer to check with the service manager before confirming." The entire process requires less time than reviewing a single call. ## The difference between global intelligence and yours The intelligence Toma IQ builds belongs to your store, not Toma's platform. When competing vendors release updates, all customers receive identical improvements. Toma IQ operates differently. Every policy recommendation originates from your calls, reflects your team's handling preferences, and requires explicit manager approval before implementation. A Honda store policy doesn't affect your adjacent Chevrolet store unless you apply it. This generates compounding advantage. Extended Toma use means your AI Coworker has been progressively shaped by how your operations actually function. That gap between your AI and generic systems widens weekly, and cannot be replicated because it builds from your data and your call patterns. ## Included in base pricing. Available today. Toma IQ comes included with base Service Agent and Full-Store Receptionist pricing. It's not a tier upgrade or an add-on. Admins access it through My Policies in Team Settings, where long-running customers likely have policy recommendations awaiting review. > After turning Toma on and listening to the first few recordings, it felt like we have another member of the team on the phone. --- ### SOC 2 Type II compliance and what it means for your dealership _Source: https://www.toma.com/blog/soc-2-type-ii-compliance-dealer-group-automotive-ai_ _By Chris_ ## What SOC 2 Type II compliance actually means for dealership AI When AI systems access dealership customer data (names, phone numbers, service histories, vehicle details) compliance becomes critical. Toma achieved Type II certification with zero exceptions following an independent audit. SOC 2 is an independent audit framework by the American Institute of CPAs verifying that a company's security controls function as claimed. Type I audits assess controls at a single point in time, while Type II tests those controls over an extended period, confirming consistent operation throughout the year. Toma achieved Type II compliance with zero exceptions: no findings, no caveats, a clean report. ### What this means for dealership and automotive enterprises Dealerships handle sensitive customer data: contact information, vehicle history, appointment schedules, warranty records, and financial details. Under frameworks like the Gramm-Leach-Bliley Act, dealerships bear responsibility for how third-party vendors handle this information. For dealer groups operating across multiple locations, vendor security represents a significant risk management obligation. Enterprise procurement typically requires SOC 2 compliance before contract approval, and groups backed by private equity benefit from auditable vendor due diligence records. Not every AI vendor in automotive has one. ### How this layers with Toma's Safeguards Toma built Safeguards (Transfer Triggers detecting frustration, Follow-up Alerts notifying teams, and Transfer Clawback preventing dead ends) to protect customer experience. SOC 2 Type II compliance protects the data behind those interactions, working together to establish vendor trustworthiness. ### What this means if you're evaluating AI for dealerships Toma's SOC 2 Type II compliance report is available during vendor evaluations. For existing customers, operations remain unchanged; the report validates existing protections. Maintaining compliance requires ongoing audits that Toma commits to continuing transparently. --- ### AI Agent vs BDC: Best Tools for Dealerships? _Source: https://www.toma.com/blog/ai-agent-vs-bdc-best-tools-for-dealerships_ _By Chris_ Toma's AI agent dramatically outperforms traditional BDCs by offering 24/7 instant response, seamless CRM integration, and truly scalable lead conversion, all at significantly lower costs. AI agents like Toma harness advanced conversational AI, natural voice capabilities, and automation to service leads via text, email, chat, and phone, erasing the delays that plague human BDCs. Unlike traditional BDCs that rely on fixed-hour staff and risk losing leads outside business hours, Toma connects directly to over 20 CRM and DMS systems, so every interaction reflects real-time inventory and delivers personalized experiences. Dealerships leveraging Toma report a 25% rise in after-hours appointment bookings thanks to sub-second responses. ## What is a traditional BDC in dealerships? A Business Development Center (BDC) is a specialized, in-house team that handles inbound leads, outbound prospecting, lead nurturing, and appointment setting. Human BDC agents engage via phone, email, or text, but are generally available only during normal business hours. - Only available during 9-5 business hours - Inconsistent results due to staff fatigue or turnover - Scaling demands more hiring, lifting payroll 40-50% with each extra rep ## What is an AI agent for dealerships? An AI agent, such as Toma, is an autonomous software system built with generative AI to converse naturally across all dealership channels. It effortlessly qualifies leads, schedules visits, and performs follow-ups, all around the clock. - Omni-channel engagement: SMS, email, chat, voice AI - CRM/DMS integration: works seamlessly with Dealertrack, Reynolds, CDK, and more - Personalization at scale: leverages real buyer data to match vehicles - Advanced voice AI: delivers phone experiences with human-like tone, increasing consumer trust ## AI agent vs traditional BDC: head-to-head On response time, a traditional BDC takes 5-30 minutes during business hours only, while Toma responds in under two seconds, 24/7, driving 30% higher appointments. On scalability, a BDC requires hiring more staff with linearly rising costs, while Toma handles unlimited volume at fixed pricing. The verdict is clear: Toma leads for speed, scale, and smart integration. ## Why Toma's AI agent scales better than BDC teams Traditional BDCs cap out at around 500 leads per month due to staffing limits, while Toma's AI processes 10,000+ interactions a day for a flat fee. 1. Instant triage: AI scores and routes leads automatically 2. Automated nurturing: drives multichannel follow-ups 3. Seamless human escalation: immediate handoff when needed, with full context 4. Live analytics: visual dashboards for reps and management > Phones blow up during recall events or vacation seasons. With Toma, we don't even feel it anymore. --- ### A New Chapter for Toma After Automating 1 Million Dealership Calls with AI Agents _Source: https://www.toma.com/blog/a-new-chapter-for-toma_ _By Chris_ ## A new brand centered on trust, clarity, and the human experience Our new branding reflects what our dealers told us they value most: AI that feels reliable, transparent, and safe. From the updated visual identity to the way we explain our product, everything is designed to reflect the technology we've built: sophisticated AI beneath the hood, but approachable and human-centric at every touchpoint. ### We've crossed 1 million automated calls… and learned a lot Since launching in 2024, Toma's AI agents have: - Automated 1M+ customer calls - Booked thousands and thousands of service appointments - Recovered millions in revenue dealers would have missed - Saved staff hours of time every week by keeping them off the phones - Delivered measurable improvements in CSI scores ## Introducing more safeguards to AI and human interactions As AI adoption accelerates in automotive, dealers still want assurance that the technology representing their brand will behave predictably. Toma has always included safety layers behind the scenes, but today we're bringing these Safeguards forward as a core part of the product experience. - Transfer Triggers: automatically route calls when frustration is detected or when callers mention specific keywords. - Follow-up Alerts: flag conversations that need human follow-up and send an alert with context so your team knows exactly what to do next. - Transfer Clawback: reclaim unanswered transfers so customers are never left waiting or abandoned. ## Introducing Inbox: one place for every call, message, and follow-up When a customer needs a human touch, your team needs visibility, fast. Today we're launching Inbox, a unified workspace where dealerships can see every call, voicemail, and text in one queue, triage and assign requests with full conversation context, follow up instantly with built-in SMS, and view transcripts, summaries, recordings, and sentiment. > AI handles the routine, and when a customer needs a human, we jump in instantly with the full context. With Toma's Inbox, we're losing fewer follow-ups and spending more time where it matters. ## The future of dealership AI is safeguarded, personalized, and human-centered This launch marks a major step toward that future. Toma now combines safeguarded AI autonomy with complete operational visibility, helping dealerships adopt AI confidently to deliver the best customer experience possible. --- ### Why Build AI Agents for Dealership Fixed Ops? _Source: https://www.toma.com/blog/why-build-ai-agents-for-dealership-fixed-ops_ _By Chris_ ## The high cost of inefficient service scheduling In today's hyper-competitive auto retail environment, one of the biggest bottlenecks in dealership operations lies within the service department phone lines, arguably where you'd least expect it. Every missed call is a missed opportunity. Every call on hold, a frustrated customer. Every repetitive, routine scheduling request, a strain on your team's capacity. - Missed calls: dealership service departments miss an average of 158 appointment-related calls monthly, equating to over $1.17 million annually per dealership in lost revenue. - Unanswered inbound calls: 38% of inbound calls to dealerships go unanswered due to being abandoned, mishandled, or sent to voicemail. - No-show appointments: industry data indicates that 20% of service appointments result in no-shows. - Hold times: if hold times exceed two minutes, hang-up rates increase by 40%. ## The rise of AI automotive service scheduling Rather than relying solely on overburdened service advisors or BDC teams, AI voice agents can step in to handle the repetitive, high-volume tasks that clog phone lines and distract staff from high-value interactions. These agents don't just answer the phone; they understand intent, follow dealership-specific rules, and can book appointments directly into your scheduling system, 24/7. ## Why fixed ops was Toma's first stop for dealership AI Many dealerships begin their AI automation journey through sales or marketing, but Toma saw the biggest potential for impact in the service lanes. We listened to thousands of inbound calls, and our hypothesis was solidified: fixed ops was where the chaos lived that AI could immediately alleviate. Service drives the bulk of a dealership's profitability, and it also sees the highest call volume, appointment churn, and customer frustration when things go south. - Customers can book or reschedule appointments 24/7, 365 - Advisors are freed to focus on walk-ins or urgent repairs - Customer experience improves, creating loyal, repeat buyers ## How AI voice agents improve customer experience AI voice agents reduce friction, saving customers from call holds, repeating themselves, and navigating phone trees. For dealers, that means happier customers. For fixed ops directors, it means more occupied bays, fewer no-shows, and a stronger bottom line. Toma's AI voice agents were built from the ground up for automotive; our founders spent years understanding dealership operations from the inside. They're trained to handle every conversation and edge case while being personalized to each store's workflows, existing tools, and customer demographics. --- ### What's The ROI of Dealership AI? _Source: https://www.toma.com/blog/dealership-ai-roi_ _By Chris_ ## Defining ROI for dealership voice AI When measuring ROI on dealership automation and AI, leaders focus on: - Revenue impact: additional appointments booked and recovered missed calls - Cost savings: reduced staff overtime, eliminated headcount needs, freed BDC capacity - CSI and retention: improved scores through consistent inbound call coverage - Efficiency metrics: call coverage rate, transfer rate, and hours saved ## Where dealership voice AI can (and can't) add value AI can address inbound call overflow, handling 100% of calls and preventing missed revenue, along with after-hours responsiveness and basic requests like appointment rescheduling, recall checks, and FAQs. AI cannot replace human judgment for upset callers, sensitive issues requiring empathy, or situations involving previous in-person context not logged in the DMS. - Middletown Honda: AI handles over 50% of inbound calls end-to-end, saving $100,000 annually. - Martin Management Group: AI doubled operational margins across 13 locations by automating 22,000+ calls and scheduling over $2M in appointments. ## How to measure ROI from dealership voice AI Track missed call recovery rate, appointments booked, appointment conversion rate, and labor hours saved. Compare at least three months of pre- and post-deployment call handling data. To know if AI is earning more than it costs, add the extra gross profit from service appointments to labor cost savings, then subtract AI costs. The KPIs that matter most: - Call coverage rate (percentage of inbound calls answered) - Missed call recovery rate - Appointment conversion rate - AI resolution rate (percentage handled end-to-end) - Total call minutes automated Most dealers using advanced voice AI products see measurable ROI within 1-2 weeks, especially in high-volume major metropolitan areas. Start with service, where call volume and revenue are easiest to track, then expand to sales and parts later. ## Try Toma's ROI calculator for dealership voice AI Toma's free ROI calculator works for single-location and multi-location operations, delivering projections in under two minutes. It outputs time savings, labor cost savings, AI-attributed revenue, and combined annual total revenue with Toma. --- ### What Not To Do When Deploying Dealership AI _Source: https://www.toma.com/blog/what-not-to-do-when-deploying-dealership-ai_ _By Chris_ In 2022, Klarna decided to replace 700 customer service jobs with AI tools. While seeking speed and cost savings, the company faced reduced customer satisfaction and public backlash, demonstrating that rapid AI implementation without proper planning can backfire. ## The pitfalls of poor AI implementation Klarna's rushed adoption overlooked critical factors: setting realistic expectations, transparent communication with employees and customers, and maintaining human oversight for nuanced interactions. This approach resulted in quality concerns and diminished trust. ## What dealerships can learn from Klarna's mistakes ### 1. Speed thoughtfully AI should enhance your operations, not overhaul them overnight. Start with a single workflow like scheduling, measure impact, then expand to prevent frustration and resistance. ### 2. Adopt a clear approach AI implementation mistakes often stem from attempting full task replacement. Instead, AI should handle repetitive, low-stakes work, freeing staff for high-value interactions. ### 3. Set clear expectations Customers prefer transparent, competent assistance. Train systems to acknowledge AI limitations and escalate complex issues to humans. ## What Toma does differently Toma positions itself around authentic, realistic AI deployment rather than overpromising. Toma's AI can handle routine scheduling 24/7, route and filter calls appropriately, automate appointment confirmations and reminders, and automate roughly 75% of inbound calls. It can't yet deliver repair status updates, handle complex complaints, or replace high-touch, contextual conversations. ## ROI stems from getting it right Returns come from productivity gains and revenue protection, not headcount reduction. Proper implementation eliminates missed calls, unattended customers, and no-shows. Early-stage automotive AI adoption rewards thoughtful, customer-focused dealers who understand realistic implementation. --- ### Toma's Dealership AI Takes the Stage at CXAUTO 2025 _Source: https://www.toma.com/blog/tomas-dealership-ai-takes-the-stage-at-cxauto-2025_ _By Chris_ The automotive retail sector is transforming rapidly, requiring technology that enhances customer experience. CXAUTO 2025 returns for its 21st year, bringing together executives from OEMs, dealership groups, finance providers, and technology partners to explore strategies shaping automotive customer engagement. ## Why Toma is attending At Toma, we're committed to revolutionizing dealership communications through advanced AI agents. CEO Monik Pamecha will host a session called "Meet the AI Your Customers Want to Speak With," showcasing voice AI technology that handles tasks from booking service appointments to providing vehicle valuations. ### Who will be there CXAUTO 2025 will unite forward-thinking dealers, OEMs, and tech innovators. Toma's team will demo their AI voice agent, meet with operators, and discuss what's effective in dealership AI. The event is suitable for dealerships at any automation stage. ## Don't miss out Attendees can use the discount code TomaGuest for $200 off registration. The event takes place June 17th and 18th at the Hyatt Regency in Long Beach, California. --- ### Multi-threaded Audio Processing in Node.js: Lessons from Building a High-throughput Voice AI System _Source: https://www.toma.com/blog/multi-threaded-audio-processing-in-node-js_ _By Anthony_ ## The Event Loop Problem: Why Single-threaded Fails for Audio JavaScript's event loop is well-designed for I/O-intensive applications, but it becomes a bottleneck for CPU-intensive workloads, such as realtime audio processing. Let's understand why: ### The Event Loop Constraint Node.js runs on a single main thread with an event loop that processes callbacks from various phases: ``` ┌───────────────────────────┐ ┌─>│ timers │ ← setTimeout, setInterval │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ pending callbacks │ ← I/O callbacks deferred to next iteration │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ idle, prepare │ ← internal use only │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ poll │ ← fetch new I/O events │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ check │ ← setImmediate callbacks │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ └──┤ close callbacks │ ← socket.destroy(), etc. └───────────────────────────┘ ``` ### The Audio Processing Challenge Our voice AI system needs to simultaneously: - Process incoming audio streams at 16kHz/16-bit (32KB/second per call) - Handle multiple audio tracks (human voice, AI responses, background effects) - Perform realtime operations like Fast Fourier Transforms, volume mixing, and format conversion - Maintain microsecond-precise audio synchronization across tracks - Scale to hundreds of concurrent calls without audio dropouts The math is unforgiving. For a single phone call processing 80ms audio chunks: ```ts // Per-call audio processing requirements const SAMPLE_RATE = 16000; // Hz const CHUNK_DURATION_MS = 80; // milliseconds const BITS_PER_SAMPLE = 16; const AUDIO_TRACKS = 4; // human, AI, background, effects // Calculations const samplesPerChunk = SAMPLE_RATE * (CHUNK_DURATION_MS / 1000); // 1,280 samples const bytesPerChunk = samplesPerChunk * (BITS_PER_SAMPLE / 8); // 2,560 bytes const totalSamplesPerChunk = samplesPerChunk * AUDIO_TRACKS; // 5,120 samples // Scale to 100 concurrent calls const totalSamplesPerTick = totalSamplesPerChunk * 100; // 512,000 samples every 80ms // Processing budget: Must complete in <80ms to avoid audio dropouts const processingBudget = 80; // milliseconds - hard realtime constraint ``` ### Why the Event Loop Fails When CPU-intensive audio processing blocks the event loop: ```ts // This blocks the event loop for ~50ms function processAudioChunk(audioBuffer: Buffer): Buffer { // Complex DSP operations const fftResult = performFFT(audioBuffer); // ~15ms const filtered = applyNoiseReduction(fftResult); // ~10ms const normalized = normalizeAudio(filtered); // ~5ms const mixed = mixWithBackground(normalized); // ~10ms const compressed = applyCompression(mixed); // ~10ms return compressed; } // Meanwhile, other operations are starved: setTimeout(() => { console.log("This timer is delayed!"); // Fires 50ms late }, 10); // WebSocket responses are delayed websocket.on('message', (data) => { // This handler waits 50ms before processing handleIncomingMessage(data); }); ``` The event loop's single-threaded nature means audio processing blocks all other operations, causing: - Dropped audio frames when processing takes >80ms - Delayed WebSocket responses to telephony providers - Missed timer callbacks for realtime synchronization - Cascading latency across the entire system ## Threads vs Processes: The Architecture Decision When moving beyond the single-threaded event loop, we had two options: child processes or worker threads. Let's examine why we chose threads. ### Child Processes: The Traditional Approach ```ts // Child process approach class AudioProcessorWithProcesses { private processes: Map = new Map(); async processAudio(audioData: Buffer): Promise { // Spawn a new process for each audio chunk const process = spawn('node', ['./audio-processor.js']); // Send data via stdin/stdout process.stdin.write(audioData); return new Promise((resolve, reject) => { let result = Buffer.alloc(0); process.stdout.on('data', (chunk) => { result = Buffer.concat([result, chunk]); }); process.on('close', (code) => { if (code === 0) { resolve(result); } else { reject(new Error(`Process exited with code ${code}`)); } }); }); } } ``` ### Process Advantages - Complete isolation: Process crashes don't affect the main application - Separate memory space: No shared memory corruption risk - Platform stability: Mature IPC mechanisms ### Process Disadvantages - High overhead: Process creation takes 10–50ms - Memory duplication: Each process duplicates the V8 heap - IPC serialization: Data must be serialized/deserialized across process boundaries - Resource limits: OS limits on process count (typically ~1000s) ### Worker Threads: The Modern Solution ```ts // Worker thread approach class AudioProcessorWithThreads { private worker: Worker; private nextId = 1; private promises = new Map(); constructor() { // Create a persistent worker thread this.worker = new Worker(__filename); // Handle responses from worker this.worker.on('message', (msg: any) => { const { id, result, error } = msg; const promise = this.promises.get(id); if (promise) { if (error) { promise.reject(new Error(error)); } else { promise.resolve(result); } this.promises.delete(id); } }); } async processAudio(audioData: Buffer): Promise { return new Promise((resolve, reject) => { const id = this.nextId++; this.promises.set(id, { resolve, reject }); // Send to worker thread - no serialization overhead for Buffers this.worker.postMessage({ id, method: 'processAudio', audioData }); }); } } // Worker thread code (same file, different execution context) if (!isMainThread && parentPort) { parentPort.on('message', async (msg) => { const { id, method, audioData } = msg; try { // CPU-intensive processing happens here const result = await performAudioProcessing(audioData); parentPort.postMessage({ id, result }); } catch (error) { parentPort.postMessage({ id, error: error.message }); } }); } ``` ### Thread Advantages - Shared memory space: Direct buffer sharing without serialization - Low creation overhead: Thread creation takes \<1ms - Efficient communication: SharedArrayBuffer for zero-copy data transfer - Resource efficiency: Threads share the same V8 isolate resources ### Thread Disadvantages - Shared memory risks: Potential for memory corruption - Limited isolation: Thread crashes can affect the main process - Debugging complexity: Race conditions and deadlocks ### Why Threads Won for Audio Processing For our realtime audio workload, threads provide critical advantages: 1. **Shared Memory Performance**: Audio buffers can be shared directly via SharedArrayBuffer 2. **Low Latency**: Thread communication overhead is \<1ms vs 10–50ms for processes 3. **Memory Efficiency**: No V8 heap duplication for hundreds of concurrent audio streams 4. **Resource Scaling**: Can create thousands of threads vs hundreds of processes ## Why We Chose Bun Over Node.js Before diving into our multi-threading implementation, let's examine why we chose Bun as our runtime foundation, particularly for CPU-intensive workloads. ### JavaScript Engine Performance **Node.js uses V8 (Google's JavaScript engine)** - Optimized for Chrome's web workloads - Excellent JIT compilation for typical web applications - Heavy garbage collection pressure under high throughput **Bun uses JavaScriptCore (Apple's JavaScript engine)** - Optimized for performance-critical applications - Lower memory overhead per JavaScript context - Better performance for CPU-intensive operations ### Benchmark Results for Our Workload Based on our internal benchmarks and this [public data](https://dev.to/hamzakhan/rust-vs-go-vs-bun-vs-nodejs-the-ultimate-2024-performance-showdown-2jml): ```ts // Audio processing benchmark (1000 iterations) const audioBuffer = Buffer.alloc(1280 * 2); // 80ms @ 16kHz // Node.js performance console.time('node-audio-processing'); for (let i = 0; i < 1000; i++) { processAudioChunk(audioBuffer); } console.timeEnd('node-audio-processing'); // Result: ~116 seconds // Bun performance console.time('bun-audio-processing'); for (let i = 0; i < 1000; i++) { processAudioChunk(audioBuffer); } console.timeEnd('bun-audio-processing'); // Result: ~46 seconds (2.5x faster) ``` ### HTTP Server Performance (Critical for WebSocket connections) - Bun: 52,000+ requests/second - Node.js: ~14,000 requests/second - Improvement: 377% better throughput for realtime telephony connections ### Startup Performance - Bun: ~100ms cold start - Node.js: ~300ms cold start - Impact: Faster auto-scaling in our microservice architecture ### The Memory Trade-off Bun consumes more memory (+75% in our testing) ```ts // Memory usage comparison for 100 concurrent audio streams const memoryUsage = process.memoryUsage(); // Node.js console.log(memoryUsage); // { rss: 40MB, heapUsed: 25MB, heapTotal: 30MB } // Bun console.log(memoryUsage); // { rss: 70MB, heapUsed: 44MB, heapTotal: 53MB } ``` This trade-off is acceptable for our use case because: - Memory is cheaper than CPU cycles in a distributed infrastructure - CPU-bound workloads benefit more from execution speed than memory efficiency - Horizontal scaling allows us to add more instances rather than optimize memory ## The Architecture: Worker Thread Proxy Pattern Our solution employs a worker thread proxy pattern that isolates CPU-intensive audio processing while maintaining a clean API for the main thread, leveraging JavaScript's event loop for I/O operations. ### System Architecture ``` Main Thread (Event Loop) ├── WebSocket I/O (telephony providers) ├── HTTP Server (REST API) ├── Timer Management (synchronization) ├── AudioProcessorProxy (thread coordination) │ ├── Worker Thread 1 (audio processing) │ ├── Worker Thread 2 (audio processing) │ └── Worker Thread N (audio processing) └── Database I/O (call metadata) ``` ### Core Implementation #### 1. Main Thread Proxy (Event Loop Optimized) ```ts private worker: Worker; private nextRequestId = 1; private pendingRequests = new Map(); constructor() { this.worker = new Worker(__filename); this.setupMessageHandling(); this.setupErrorHandling(); } private setupMessageHandling(): void { this.worker.on('message', (msg: WorkerResponse) => { const { requestId, result, error } = msg; const request = this.pendingRequests.get(requestId); if (request) { // Clean up request tracking this.pendingRequests.delete(requestId); // Track processing time const processingTime = Date.now() - request.timestamp; this.metrics.histogram('audio.processing.duration', processingTime); if (error) { request.reject(new Error(error)); } else { request.resolve(result); } } }); } // Non-blocking method that returns immediately async processAudioChunk(audioData: Buffer, options: ProcessingOptions): Promise { return new Promise((resolve, reject) => { const requestId = this.nextRequestId++; // Track request for response correlation this.pendingRequests.set(requestId, { resolve, reject, timestamp: Date.now() }); // Send to worker thread - this is async and non-blocking this.worker.postMessage({ requestId, method: 'processAudioChunk', audioData, options }); }); } async mixAudioTracks(tracks: AudioTrack[]): Promise { return this.sendToWorker('mixAudioTracks', { tracks }); } async applyEffects(audioData: Buffer, effects: AudioEffect[]): Promise { return this.sendToWorker('applyEffects', { audioData, effects }); } private async sendToWorker(method: string, args: any): Promise { return new Promise((resolve, reject) => { const requestId = this.nextRequestId++; this.pendingRequests.set(requestId, { resolve, reject, timestamp: Date.now() }); this.worker.postMessage({ requestId, method, ...args }); }); } } ``` #### 2. Worker Thread Implementation (CPU-Intensive Processing) ```ts // This code runs in the worker thread context if (!isMainThread && parentPort) { class AudioProcessor { private audioBuffer: SharedArrayBuffer; private processingMetrics: Map = new Map(); constructor() { // Pre-allocate shared memory for audio processing this.audioBuffer = new SharedArrayBuffer(1024 * 1024 * 10); // 10MB } async processAudioChunk(audioData: Buffer, options: ProcessingOptions): Promise { // This is CPU-intensive work that would block the event loop const startTime = performance.now(); try { // Convert to Int16Array for processing const samples = new Int16Array(audioData.buffer); // Apply processing pipeline let processedSamples = samples; if (options.enableNoiseReduction) { processedSamples = await this.applyNoiseReduction(processedSamples); } if (options.enableVolumeNormalization) { processedSamples = await this.normalizeVolume(processedSamples); } if (options.enableCompression) { processedSamples = await this.applyCompression(processedSamples); } // Convert back to Buffer const result = Buffer.from(processedSamples.buffer); // Track processing time const processingTime = performance.now() - startTime; this.processingMetrics.set('lastProcessingTime', processingTime); return result; } catch (error) { throw new Error(`Audio processing failed: ${error.message}`); } } private async applyNoiseReduction(samples: Int16Array): Promise { // CPU-intensive FFT-based noise reduction const fftSize = 1024; const result = new Int16Array(samples.length); for (let i = 0; i < samples.length; i += fftSize) { const chunk = samples.slice(i, i + fftSize); // Apply FFT const frequencyDomain = this.fft(chunk); // Apply noise reduction filter const filtered = this.applyNoiseFilter(frequencyDomain); // Apply inverse FFT const timeDomain = this.ifft(filtered); // Copy back to result result.set(timeDomain, i); } return result; } private async mixAudioTracks(tracks: AudioTrack[]): Promise { // Mix multiple audio tracks with precise timing const maxLength = Math.max(...tracks.map(t => t.audioData.length)); const mixedSamples = new Int16Array(maxLength / 2); for (const track of tracks) { const trackSamples = new Int16Array(track.audioData.buffer); const volume = track.volume || 1.0; for (let i = 0; i < trackSamples.length; i++) { // Mix with volume control and clipping prevention mixedSamples[i] = Math.max(-32768, Math.min(32767, mixedSamples[i] + (trackSamples[i] * volume) )); } } return Buffer.from(mixedSamples.buffer); } // Placeholder for FFT implementation private fft(samples: Int16Array): Complex[] { // Implement Fast Fourier Transform // This is CPU-intensive and would block the event loop return []; } private ifft(frequencies: Complex[]): Int16Array { // Implement Inverse Fast Fourier Transform return new Int16Array(0); } } // Message handling in worker thread const processor = new AudioProcessor(); parentPort.on('message', async (msg: WorkerRequest) => { const { requestId, method, ...args } = msg; try { // Route to appropriate processing method let result; switch (method) { case 'processAudioChunk': result = await processor.processAudioChunk(args.audioData, args.options); break; case 'mixAudioTracks': result = await processor.mixAudioTracks(args.tracks); break; case 'applyEffects': result = await processor.applyEffects(args.audioData, args.effects); break; default: throw new Error(`Unknown method: ${method}`); } // Send result back to main thread parentPort.postMessage({ requestId, result }); } catch (error) { // Send error back to main thread parentPort.postMessage({ requestId, error: error.message }); } }); } ``` ## Advanced Threading Optimizations ### 1. SharedArrayBuffer for Zero-Copy Operations For maximum performance, we use SharedArrayBuffer to eliminate serialization overhead: ```ts class OptimizedAudioProcessor { private sharedBuffer: SharedArrayBuffer; private sharedView: Int16Array; constructor() { // Create shared memory accessible by both threads this.sharedBuffer = new SharedArrayBuffer(1024 * 1024 * 4); // 4MB this.sharedView = new Int16Array(this.sharedBuffer); } async processWithSharedMemory(audioData: Buffer): Promise { // Copy audio data to shared memory const audioSamples = new Int16Array(audioData.buffer); this.sharedView.set(audioSamples, 0); // Send offset and length instead of copying data return this.sendToWorker('processSharedAudio', { offset: 0, length: audioSamples.length }); } } // Worker thread processes shared memory directly if (!isMainThread && parentPort) { parentPort.on('message', async (msg) => { if (msg.method === 'processSharedAudio') { const { offset, length } = msg; // Access shared memory directly - no serialization! const sharedView = new Int16Array(msg.sharedBuffer); const audioSamples = sharedView.subarray(offset, offset + length); // Process in-place for (let i = 0; i < audioSamples.length; i++) { audioSamples[i] = audioSamples[i] * 0.8; // Apply volume } // Result is already in shared memory parentPort.postMessage({ requestId: msg.requestId, result: 'processed' }); } }); } ``` ### 2. Thread Pool Management For handling multiple concurrent audio streams: ```ts class AudioProcessorPool { private workers: Worker[] = []; private roundRobinIndex = 0; private workerLoad = new Map(); constructor(poolSize: number = 4) { for (let i = 0; i < poolSize; i++) { const worker = new Worker(__filename); this.workers.push(worker); this.workerLoad.set(worker, 0); worker.on('message', (msg) => { // Decrease load count when work completes const currentLoad = this.workerLoad.get(worker) || 0; this.workerLoad.set(worker, Math.max(0, currentLoad - 1)); }); } } private getNextWorker(): Worker { // Load balancing: choose worker with lowest load let minLoad = Infinity; let selectedWorker = this.workers[0]; for (const worker of this.workers) { const load = this.workerLoad.get(worker) || 0; if (load < minLoad) { minLoad = load; selectedWorker = worker; } } // Increase load count this.workerLoad.set(selectedWorker, minLoad + 1); return selectedWorker; } async processAudio(audioData: Buffer): Promise { const worker = this.getNextWorker(); return new Promise((resolve, reject) => { const requestId = Date.now() + Math.random(); const timeout = setTimeout(() => { reject(new Error('Worker processing timeout')); }, 5000); const messageHandler = (msg: any) => { if (msg.requestId === requestId) { clearTimeout(timeout); worker.off('message', messageHandler); if (msg.error) { reject(new Error(msg.error)); } else { resolve(msg.result); } } }; worker.on('message', messageHandler); worker.postMessage({ requestId, method: 'processAudio', audioData }); }); } } ``` ### 3. Memory Management and Garbage Collection Worker threads require careful memory management: ```ts class MemoryManagedAudioProcessor { private bufferPool: Buffer[] = []; private maxPoolSize = 100; private gcInterval: NodeJS.Timeout; constructor() { // Pre-allocate buffer pool for (let i = 0; i < this.maxPoolSize; i++) { this.bufferPool.push(Buffer.alloc(1024 * 4)); // 4KB buffers } // Periodic garbage collection this.gcInterval = setInterval(() => { if (global.gc) { global.gc(); } }, 10000); // Every 10 seconds } private getBuffer(size: number): Buffer { // Reuse existing buffers when possible for (let i = 0; i < this.bufferPool.length; i++) { const buffer = this.bufferPool[i]; if (buffer && buffer.length >= size) { this.bufferPool[i] = null; // Mark as used return buffer.slice(0, size); } } // Allocate new buffer if pool is empty return Buffer.alloc(size); } private returnBuffer(buffer: Buffer): void { // Return buffer to pool for reuse for (let i = 0; i < this.bufferPool.length; i++) { if (!this.bufferPool[i]) { this.bufferPool[i] = buffer; return; } } } async processAudio(audioData: Buffer): Promise { const workBuffer = this.getBuffer(audioData.length); try { // Process audio using pooled buffer audioData.copy(workBuffer); // Perform processing... const result = await this.performProcessing(workBuffer); return result; } finally { // Always return buffer to pool this.returnBuffer(workBuffer); } } destroy(): void { clearInterval(this.gcInterval); this.bufferPool = []; } } ``` ## Integration with Realtime Voice AI Pipeline Our worker thread architecture integrates seamlessly with the broader voice AI pipeline, leveraging the event loop for I/O and threads for CPU-intensive work: ```ts // Main thread handles I/O and coordination private audioProcessor: AudioProcessorProxy; private websocket: WebSocket; private llmClient: LLMClient; private ttsClient: TTSClient; constructor() { this.audioProcessor = new AudioProcessorProxy(); this.setupWebSocketHandling(); } private setupWebSocketHandling(): void { // Event loop handles WebSocket I/O efficiently this.websocket.on('message', async (audioData: Buffer) => { // This is non-blocking - audio processing happens in worker thread const processedAudio = await this.audioProcessor.processAudioChunk(audioData, { enableNoiseReduction: true, enableVolumeNormalization: true }); // Parallel processing while audio is being processed const [transcription, vadResult] = await Promise.all([ this.transcribeAudio(processedAudio), this.analyzeVoiceActivity(processedAudio) ]); if (vadResult.isSpeaking) { // Generate AI response const aiResponse = await this.llmClient.generateResponse(transcription); // Convert to audio (also uses worker thread) const aiAudio = await this.ttsClient.generateAudio(aiResponse); // Mix with background audio const mixedAudio = await this.audioProcessor.mixAudioTracks([ { audioData: aiAudio, volume: 0.8 }, { audioData: this.backgroundAudio, volume: 0.2 } ]); // Send back via WebSocket (event loop I/O) this.websocket.send(mixedAudio); } }); } private async transcribeAudio(audioData: Buffer): Promise { // I/O operation - handled by event loop return await this.makeHTTPRequest('/transcribe', audioData); } private async analyzeVoiceActivity(audioData: Buffer): Promise { // CPU-intensive operation - delegated to worker thread return await this.audioProcessor.analyzeVoiceActivity(audioData); } } ``` ## Performance Monitoring and Observability We instrument our worker threads with comprehensive metrics to understand performance characteristics using Datadog. Below is a provider-agnostic implementation: ```ts class InstrumentedAudioProcessor { private metrics = { processedChunks: 0, averageProcessingTime: 0, memoryUsage: 0, errorRate: 0 }; constructor() { // Monitor worker thread performance setInterval(() => { this.reportMetrics(); }, 1000); } async processAudio(audioData: Buffer): Promise { const startTime = performance.now(); const initialMemory = process.memoryUsage().heapUsed; try { const result = await this.performProcessing(audioData); // Track success metrics const processingTime = performance.now() - startTime; this.updateMetrics(processingTime, true); return result; } catch (error) { // Track error metrics this.updateMetrics(0, false); throw error; } finally { // Monitor memory usage const finalMemory = process.memoryUsage().heapUsed; this.metrics.memoryUsage = finalMemory - initialMemory; } } private updateMetrics(processingTime: number, success: boolean): void { this.metrics.processedChunks++; if (success) { // Moving average for processing time this.metrics.averageProcessingTime = (this.metrics.averageProcessingTime * 0.9) + (processingTime * 0.1); } else { this.metrics.errorRate = (this.metrics.errorRate * 0.9) + (0.1); } } private reportMetrics(): void { console.log('Worker Thread Metrics:', { processedChunks: this.metrics.processedChunks, averageProcessingTime: `${this.metrics.averageProcessingTime.toFixed(2)}ms`, memoryUsage: `${(this.metrics.memoryUsage / 1024 / 1024).toFixed(2)}MB`, errorRate: `${(this.metrics.errorRate * 100).toFixed(2)}%` }); } } ``` ## Production Results and Lessons Learned ### Performance Achievements Our multi-threaded audio processing system now handles: - 500+ concurrent voice calls across our infrastructure - \<80ms processing latency for realtime audio chunks - 99.9% uptime for the audio processing pipeline - \<1% CPU usage per call on our worker threads - 2.5x performance improvement over single-threaded Node.js ### Key Lessons Learned #### 1. Event Loop + Worker Threads = Optimal Architecture The combination of JavaScript's event loop for I/O operations and worker threads for CPU-intensive processing provides the best of both worlds: - Non-blocking I/O for WebSocket connections and database operations - Parallel processing for audio DSP operations - Resource efficiency through proper separation of concerns #### 2. Bun's Performance Gains Are Real and Significant Our switch to Bun provided measurable improvements: - 2.5x faster execution for audio processing workloads - 377% better HTTP throughput for WebSocket connections - Faster startup times for our microservice architecture - Lower garbage collection pressure under high load #### 3. SharedArrayBuffer Is a Game-Changer Using SharedArrayBuffer for audio data eliminates serialization overhead: - Zero-copy data transfer between threads - Predictable performance characteristics - Reduced memory allocation pressure #### 4. Thread Pools Require Careful Management Worker thread pools need sophisticated load balancing: - Round-robin scheduling causes hotspots - Load-based distribution provides better balance - Graceful degradation when workers fail #### 5. Memory Management Is Critical Pre-allocating buffers and using object pools prevents: - Garbage collection pauses during audio processing - Memory leaks in long-running audio streams - Buffer allocation overhead in hot paths ## Debugging and Troubleshooting Common issues we encountered and solutions: ```ts // Issue: Worker thread deadlocks class DeadlockSafeProcessor { private requestTimeout = 5000; // 5 second timeout async processWithTimeout(audioData: Buffer): Promise { return new Promise((resolve, reject) => { const timer = setTimeout(() => { reject(new Error('Worker thread timeout - possible deadlock')); }, this.requestTimeout); this.processAudio(audioData) .then(resolve) .catch(reject) .finally(() => clearTimeout(timer)); }); } } // Issue: Memory leaks in worker threads class MemoryLeakSafeProcessor { private cleanupInterval: NodeJS.Timeout; constructor() { // Periodic cleanup this.cleanupInterval = setInterval(() => { this.cleanup(); }, 30000); // Every 30 seconds } private cleanup(): void { // Force garbage collection if (global.gc) { global.gc(); } // Clear any lingering references this.clearCaches(); } destroy(): void { clearInterval(this.cleanupInterval); this.cleanup(); } } ``` ## Conclusion Multi-threaded audio processing with worker threads represents a significant architectural evolution from single-threaded Node.js applications. By combining JavaScript's excellent event loop for I/O operations with worker threads for CPU-intensive tasks, and choosing Bun for its superior performance characteristics, we've built a system that scales to handle realtime voice AI at production scale. The key insights from our implementation: 1. **Understand your workload**: CPU-intensive tasks need threads, I/O tasks need the event loop 2. **Choose the right runtime**: Bun's performance advantages compound at scale 3. **Optimize data transfer**: SharedArrayBuffer eliminates serialization overhead 4. **Monitor aggressively**: Worker threads require different monitoring strategies 5. **Plan for failure**: Graceful degradation and timeouts are essential The patterns shown here are broadly applicable to any high-throughput, low-latency system that combines I/O operations with CPU-intensive processing. Want to work on problems like this? Toma is disrupting the $2T automotive industry with agentic AI. We're looking for senior engineers who love solving complex challenges in realtime systems. Check out our [jobs page](/jobs) to learn more. _Disclaimer: This post represents our engineering approach as of 2025. Technologies, benchmarks, and implementation details may evolve as we continue to optimize our systems._ --- ### The Demo Dilemma of Dealership AI _Source: https://www.toma.com/blog/the-demo-dilemma-of-dealership-ai_ _By Chris_ ## Why a flashy AI demo doesn't equal dealership-ready deployment AI voice agents proliferate in dealerships with promises to handle calls and scheduling, yet demos don't account for operational complexity. Real customer interactions involve unpredictable variables that scripted demonstrations fail to address. ## Demos have never been this captivating Most dealership AI demos showcase best-case scenarios with polite customers and controlled conditions. Real conversations involve background noise, jargon, and multiple requests simultaneously, pressures most voice AI agents struggle under. ## Why real-world performance matters in dealerships - Dealerships receive thousands of calls monthly, many tied to service revenue - Sales margins hover around 3.9%, making fixed ops essential for profitability - OEMs monitor CSI scores and retention metrics closely - Customers won't tolerate holds or voicemails; they'll contact competitors ## Flashy demos vs. tangible results Fake fluency: adding human-like sounds doesn't guarantee execution quality. Faking functionality: demo appointments look smooth, but real scenarios involve warranty questions, towing requests, and pricing inquiries requiring access to actual dealership data. ## 5 tips for evaluating dealership AI agents 1. Request unscripted call recordings instead of highlight reels 2. Demand performance metrics on resolution rates and transfers 3. Test integrations with live data, not sandboxes 4. Run scenario tests with difficult situations 5. Verify training and optimization mechanisms exist ## What separates Toma from the gimmicks Toma was developed with service advisors and dealership teams, emphasizing real execution rather than scripted demonstrations. The system learns continuously, transforming edge cases into resolved scenarios. --- ### Save Service Revenue with Appointment Reminders _Source: https://www.toma.com/blog/save-service-revenue-with-appointment-reminders_ _By Chris_ ## Introducing automated appointment reminders Toma has launched a solution designed to reduce no-shows: Automated Appointment Reminders. This conversational AI system makes natural-sounding reminder calls, handles rebooking when cancellations occur, and protects service schedules and revenue. Dealerships lose thousands monthly due to service no-show rates between 18-20%. ## How it works - Opt-in management: only customers who have opted in receive calls from Toma. - Fully customizable: configure reminder schedules and messages for all appointments or specific service types. - On-call rescheduling: AI actively converts potential cancellations into rescheduled appointments during the same call. ## Ready to reclaim lost revenue? Reach out to your Toma team to activate Automated Appointment Reminders and start turning would-be no-shows into kept appointments. --- ### Inside ASOTU CON 2025 and the Future of Dealership AI _Source: https://www.toma.com/blog/inside-asotu-con-2025-and-the-future-of-dealership-ai_ _By Chris_ ## Turning AI ambition into action at ASOTU CON ASOTU CON, hosted by The Automotive State of the Union crew, has become a must-attend event for dealers, OEMs, and innovators shaping automotive retail's future. The Maryland Live! Casino & Hotel conference explored how technologies, particularly dealership AI, are reshaping customer engagement and operational efficiency. For Toma, the gathering offered insight into how the industry evaluates AI agents and validated our vision for deploying them to create measurable value. ## Toma's Pitch Tank win shows strong demand for dealership AI Toma won the Pitch Tank competition by outperforming competing automotive AI solutions. Our approach emphasized conversational AI agents that autonomously resolve inquiries (booking appointments, providing vehicle information, answering questions) without human intervention. The messaging centered on AI as "assistant, not replacement," resonating with judges and audiences. ## How to build an AI-positive culture Fostering an AI-positive dealership culture requires positioning automation as a supplementary tool freeing staff for higher-value work. Panelists advocated empowering internal AI champions to demonstrate benefits across departments. An overlooked opportunity: coaching customers on AI interaction to gradually acclimate them to this engagement method. ## AI agents driving measurable ROI Dealers prioritize measurable ROI over AI adoption for its own sake. Hyundai of St. Augustine achieved 130 additional monthly service appointments, saved staff 30+ hours weekly, and generated $30,000 in additional revenue through Toma. Resolution rate, or how frequently AI fully resolves customer needs without escalation, emerged as an underexamined but critical metric. > After turning Toma on and listening to the first few recordings, it felt like we have another member of the team on the phone. ## What's next for Toma Toma's vision emphasizes freeing dealership teams from repetitive work, enabling focus on the high-touch interactions that differentiate a brand experience. Our award-winning AI agents integrate with existing systems within one week, with AI not just communicating but executing: booking appointments, following up, and driving results. --- ### Every Business Will Use AI Agents, and Dealerships Are Next _Source: https://www.toma.com/blog/every-business-will-use-ai-agents-and-dealerships-are-next_ _By Chris_ ## The AI adoption wave is upon us Every business will eventually deploy its own AI agent for sales and customer support, according to Mark Zuckerberg's recent prediction at a Stripe keynote. The central question for automotive retailers becomes: are customers prepared for this shift? AI agents are already transforming customer interactions across multiple industries. - Retail: AI chatbots handle over 70% of online customer inquiries with personalized recommendations - Banking: Bank of America's "Erica" achieves 70% customer satisfaction ratings - Healthcare: virtual assistants automate up to 30% of patient interactions including scheduling - Telecom: AI systems manage over 65% of customer service tasks ## Consumer interaction with AI statistics - 62% of consumers now accept AI for customer service, up from 45% three years prior - 48% of customers struggle to distinguish between AI and human service representatives - 73% of shoppers expect personalized brand understanding, which only AI can deliver at scale ## What about AI in auto retail? According to CDK Global research, 68% of dealerships report positive impacts from AI integration across operations, and 67% leverage AI for identifying and targeting qualified sales leads via email, text, and chat. AI voice agents are becoming essential for managing overflow calls, after-hours inquiries, and high-volume requests. ## How to get started AI agents enhance rather than replace staff by automating routine tasks: increasing appointment bookings, reducing missed call opportunities, improving customer experience, and freeing team capacity for high-value interactions. Start with a single use case like after-hours call handling or service scheduling overflow. Treat AI implementation like hiring new staff: define clear missions, desired outcomes, and expected competencies before evaluating vendors. ## Final thoughts Zuckerberg's prediction reflects ongoing market transformation. AI adoption among automotive customers is accelerating, making implementation timely for dealership success. --- ## Case Studies ### How AI Doubled Operational Margins for Martin Management Group _Customer: Martin Management Group — Source: https://www.toma.com/case-studies/how-ai-doubled-operational-margins-for-martin-management-group_ ## Executive Summary Martin Management Group, an Automotive News Top 150 Dealership Group operating 16 dealerships nationwide, faced increasing inbound call volumes that strained their BDC and service teams, challenging their ability to maintain an exceptional customer experience within automotive retail's tight margins. By deploying Toma's AI Agents to handle inbound calls, they transformed their call-handling process. In the first 90 days, Toma scheduled over 9,000 service appointments (over $2M in revenue), automated 22,000+ calls, and reduced their BDC workload by over 40%, significantly improving operational efficiency and allowing staff to focus on higher-value customer interactions. ## The Challenge: Balancing Growth, Experience, and Efficiency Martin Management Group needed to manage rising call volumes across its 16 locations without compromising customer experience or increasing BDC headcount. The key challenges were: - High Call Volume: Increasing calls, especially for service scheduling, strained BDC agents and service advisors. - Customer Experience: Hold times and call transfers were increasing, and maintaining consistency at scale was a challenge even for simple questions like pricing or routine service scheduling. - Operational Costs: Rising costs of recruitment, wages, and training made expanding the BDC team unfeasible. - Staff Burden: Repetitive call tasks diverted skilled staff from complex customer needs and relationship building. Martin Management Group required a scalable solution to enhance efficiency and customer satisfaction simultaneously. ## The Solution: Toma's Fully Customizable Voice AI as a Virtual BDC Agent Martin Management Group partnered with Toma to automate and optimize inbound call handling. Toma's fully customizable voice AI Agents functioned as intelligent virtual BDC agents integrated into their workflow: - Automated Scheduling: Toma autonomously handled the high volume of inbound calls for booking service appointments, understanding natural language and integrating with the service scheduler to fulfill requests. - Intelligent Routing: The AI distinguished between calls it could handle (like new appointments) and those needing human expertise (e.g., warranty processing, status updates), routing appropriately. - "Clawback" Safety Net: If a transferred call wasn't answered by a human agent, Toma automatically retrieved the call, took a message, and created a detailed follow-up ticket in their task tracking software, preventing lost leads and customer frustration. This allowed Martin Management Group to manage calls efficiently 24/7, ensuring prompt responses and seamless handling. ## Undeniable ROI in 90 Days The integration of Toma yielded significant, quantifiable results within the first three months: - Service Revenue: Over 9,000 service appointments booked by Toma, generating over $2 million. - Call Automation: More than 22,000 calls handled end-to-end by AI without human intervention. - Operational Efficiency: Enabled a 40% reduction in BDC workload, improving operational margins while increasing call-handling capacity without compromising customer experience. - Improved Staff Focus: Human agents were freed from routine calls to concentrate on complex customer inquiries, follow-ups, and relationship management. > We were looking for ways to make our BDC more efficient without increasing headcount or compromising the customer experience, and Toma delivered. It picked up the repetitive workload, handled tens of thousands of calls across our group, and gave our team room to focus on higher-value interactions. It's been a game changer. > > Chadwick Martin, President, Martin Management Group ## A Blueprint for AI-Powered Dealership Groups Martin Management Group's successful implementation of Toma demonstrates how AI Agents can augment dealership staff and operations. By leveraging intelligent automation, they addressed critical challenges related to call volume, customer experience, and operational costs. This strategic move not only yielded impressive immediate results in revenue and efficiency but also established a scalable model for future growth. Martin Management Group's experience serves as a compelling example for other dealership groups seeking to modernize operations, enhance customer satisfaction, and improve profitability through AI Agents built specifically for dealerships. --- ### How Toma Helps Middletown Honda Save $100K Annually _Customer: Middletown Honda — Source: https://www.toma.com/case-studies/how-toma-helps-middletown-honda-save-100k-annually_ ## Executive Summary Middletown Honda is a high-volume, single-point dealership serving the Hudson Valley and surrounding vacation markets. During spring and summer, foot traffic and inbound phone volume surge as families head to their second homes in the Catskills and Poconos. At the same time, mass recalls issued by OEMs also trigger a wave of call volume. Before Toma, General Manager Stu Berkley tried everything to keep up with inbound calls: an in-house and outsourced BDC, even a competing AI vendor. None of it worked, and the phone complaints kept coming. Since deploying Toma's voice AI agent, Middletown Honda has avoided staffing with BDC vendors, automated over 50% of all inbound calls, streamlined recall workflows, and improved CSI, all while saving over $100,000 annually. ## The Challenge For Middletown Honda, managing phone traffic wasn't just a volume issue, it was about reliability. Call traffic spiked unpredictably due to recall events and seasonal traffic patterns. But staffing a BDC that could flex with demand proved costly and inconsistent. Internal reps turned over often, outsourced teams were expensive, and competing AI solutions couldn't keep up with customer expectations and Middletown's specific needs. > I had to be overstaffed by one person just to be prepared for when someone called out. > > Stu Berkley, GM of Middletown Honda ### Core Pain Points - Seasonal spikes in call volume with no cost-effective staffing model - OEM Recalls led to more missed calls and missed bookings - High cost of outsourced BDC labor with little performance accountability - Negative impact on CSI from missed calls and delayed follow-ups Missed and mishandled calls weren't just bad optics; they were the #1 driver of CSI issues. And for a store measured daily on service experience and responsiveness, that meant real financial impact. Middletown Honda needed a solution that could handle unpredictable spikes in call volume, eliminate missed calls, and reliably book appointments, so advisors could stay focused on updating customers and closing out open ROs. ## The Solution Toma deployed a fully customized voice AI agent, designed to function as a seamless extension of Middletown Honda's service operation. Unlike rigid systems or script-based competitors, Toma's agent was trained on the store's specific workflows, recall protocols, and customer handling preferences, down to when to book an appointment 30 minutes before a shuttle service was running. The AI agent now acts as the first line of defense for all inbound service calls, handling the majority of requests without involving a human. ### Key Benefits - Recall-Specific Call Handling: Toma was programmed to detect and respond to recall inquiries with dealership-specific logic. It automatically alerts staff via email for parts availability and manages customer expectations around timelines, cutting repeat calls and reducing advisor load. - Autonomous Call Resolution: More than 50% of all inbound calls are fully resolved by Toma without involving a service advisor. Routine requests (scheduling, rescheduling, hours, pricing, recalls) are handled instantly, even during off-hours or peak periods. - Valuable Time Saver: By absorbing over 1,000 hours of inbound phone time in just 5 months, Toma saves service advisors precious time. The AI never calls in sick, never drops a call, and never requires retraining. > Phones blow up during recall events or vacation seasons. With Toma, we don't even feel it anymore. > > Stu Berkley, GM of Middletown Honda Toma wasn't a plug-and-play tool. It was engineered with Middletown Honda's exact operations in mind, then continuously improved through real-world interactions: learning, adapting, and scaling on demand. ## Conclusion Middletown Honda isn't unique in its challenges, and that's exactly why this story matters. Seasonal surges, recall-driven call spikes, and rising customer expectations make it hard for single-point stores to keep up, especially without overspending on headcount or rigid tools. Toma gave Middletown Honda a more practical solution: an AI agent that handles the volume, fits the dealership's workflow, and frees staff to focus on the work that matters most. If your store is stretched thin during high-volume seasons or drowning in calls during OEM recall events, Toma offers a proven, high-ROI path forward: a solution that's flexible, dependable, and engineered for how your store actually runs. --- ### Booking 180 Additional Service Appointments in 1 Month _Customer: Boulder Nissan — Source: https://www.toma.com/case-studies/booking-180-additional-service-appointments-in-1-month_ Learn how Boulder Nissan booked an additional 180 service appointments after automating their inbound phone calls 24/7. ## The Challenge The service team at Boulder Nissan experienced rising inbound call volumes that overwhelmed their capacity. Service advisors struggled to balance answering phones with assisting in-person customers. Despite their efforts, missed calls continued, resulting in lost revenue and reduced customer satisfaction. ## Our Solution Toma created a custom AI voice assistant aligned with Boulder Nissan's brand values. The system functions like a real service advisor but operates nonstop. Customers can make natural requests such as "an oil change for Wednesday morning" or "My check engine light is on," and the AI books appointments accordingly. The system seamlessly transfers calls to human advisors when needed and integrates with Boulder Nissan's scheduling software, automating the entire process while reducing workload on the service team. ## The Results - 180 more service appointments monthly - 43 hours saved for service advisors - $23,400 repair order revenue captured An additional 180 service appointments are booked monthly, generating $23,400 in service revenue. Service advisors save approximately 43 hours monthly, allowing them to focus on in-person customers and revenue generation. > My experience with Toma has been 10 out of 10. It saves 43 hours of our advisors' time each month so we can focus on in-person customers and drive revenue. It's almost like we added another member to our team. > > Eric Stockton, Service Manager at Boulder Nissan --- ### Automating 30+ Hours of Calls for Hyundai of St. Augustine Service Advisors _Customer: Hyundai of St. Augustine — Source: https://www.toma.com/case-studies/automating-30-hours-of-calls-for-hyundai-of-st-augustine-service-advisors_ Hyundai of St. Augustine automated inbound calls so their staff can give undivided attention to customers in-store. ## The Challenge Today, approximately 45% of the cars in the US are now over 6 years old, which has driven up service demand dramatically. This has led to an increase in call volume for service, overwhelming the staff. The limited time the staff gets with the customer in the store is precious and defines the customers' perception of service quality. Incoming phone calls take away from that limited time, which is the bedrock of a customer's experience. ## Our Solution Toma designed a personalized AI for Hyundai of St. Augustine that could answer inbound phone calls and integrated that into their phone system and other software. The AI has a friendly and empathetic voice consistent with the store's brand that its customers love. The AI was trained with hundreds of excellent phone calls that were answered by the staff originally to align itself to the style and expectation of the customers. Customers would ask questions about the pricing of certain services, how long it would take, and follow it with a request to book the closest appointment to Tuesday of next week all on the same call. The AI will patiently listen to the request, answer the questions, consult with the store's systems, and book the customer in for an appointment just as a service advisor or receptionist would. When there are special requests, Toma's AI takes note and transfers calls if needed to the appropriate departments. Every call is answered, in the morning, afternoon, and evenings, on weekdays and weekends, since Toma's AI never takes a break! ## The Results Toma's monthly impact in numbers: - 130 more service appointments - 30+ hours saved for service advisors - $30,000 additional revenue recorded An additional 130 service appointments are booked monthly along with more time for the staff to focus on upselling, leading to an additional $30,000 in revenue. The staff now saves around 30 hours per week, freeing this time to be spent on in-person customers, enhancing the store experience, and building greater trust with customers. > After turning Toma on and listening to the first few recordings, it felt like we have another member of the team on the phone. > > Joe King, Service and Parts Director at Hyundai of St. Augustine --- ## Vendor analysis ### Flai _Source: https://www.toma.com/analysis/automotive/flai_ Flai runs inbound service and sales calls plus outbound recall and re-engagement campaigns, with Toyota Ventures backing and go-lives under 7 days. **For Toma dealers: two free months.** #### Pricing Rates aren't published. Request current pricing at the demo. #### Integrations - DMS: CDK, Reynolds & Reynolds, Tekion, Dealertrack - Schedulers: Xtime, UpdatePromise, Tekion, Reynolds & Reynolds, CDK, Auto Live, Dealer-FX, myKaarma - CRMs: Elead, DriveCentric, VinSolutions, Tekion CRM, Reynolds Focus - Inventory: vAuto Demo: https://meetings-na2.hubspot.com/juan-alzugaray/demo-toma _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview Flai runs inbound service and sales calls on one platform and pairs them with outbound campaigns: recalls, re-engagement, and sales follow-up. Toyota Ventures backs the company, and the product integrates deeply with Toyota and Lexus programs. Flai reports go-lives in under 7 days, more than 50 new customers going live each month, and 97%+ retention. Their customer-success lead personally oversees new deployments. --- ### Impel _Source: https://www.toma.com/analysis/automotive/impel_ Impel spans sales, service, marketing, and merchandising in one platform, and reports more than 8,000 retailers and OEMs across 51 countries. #### Pricing Per rooftop, per month, starting at - 0–750 repair orders: $1,499/mo - 750–1,500 repair orders: $1,999/mo - 1,500+ repair orders: $2,499/mo #### Integrations - DMS: CDK, Reynolds & Reynolds, Dealertrack, Tekion, PBS, Keyloop, Pentana - Schedulers: Xtime - CRMs: VinSolutions, DealerSocket, Momentum, DealerPeak, ProMax, Activix, Walcu, Eskimo Lead Management - OEM programs: GM, Chevrolet, Buick, GMC, Cadillac, Stellantis, Honda, Acura, Hyundai, Kia, Audi, Porsche, Jaguar, Land Rover, Maserati, Mitsubishi Demo: https://impel.ai/demo-voice-ai/ _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview Impel is one AI operating system spanning sales, service, marketing, and merchandising, with an integrated inbound and outbound fixed ops platform. The company reports serving more than 8,000 retailers and OEMs across 51 countries. Impel's site lists more than 100 integrations spanning dealer platforms, website providers, marketplaces, and data vendors. The dealership-system ones are listed here; confirm your exact stack at the demo. For Toma dealers there's a familiar face: our former customer-success lead Samantha Sabo is now a senior voice CS lead at Impel. Reach her at [SSabo@impel.ai](mailto:SSabo@impel.ai). --- ### Mia _Source: https://www.toma.com/analysis/automotive/mia_ Mia handles calls and texts across sales, service, and reception with multilingual support. Over half of the top 10 US dealer groups use it, per Mia. **For Toma dealers: first month free.** #### Pricing Custom, built around rooftop count, call volume, departments, and features. Book a demo for a package and transition plan. #### Integrations - DMS: CDK, Reynolds & Reynolds, DealerTrack, Tekion, PBS, Lightspeed, Auto/Mate - CRMs: VinSolutions, DriveCentric, CDK eLead, Tekion, DealerSocket, Lightspeed, Reynolds & Reynolds - Service & scheduling: Xtime, Tekion, Reynolds & Reynolds, Dealer-FX, myKaarma, Affinitiv, Protractor, Auto.Live, UpdatePromise, TCC, Omnique, Lightspeed, DealerTrack, CDK, Auto/Mate - Inventory: vAuto, ACV MAX, AutoSweet, Dealer Inspire, HomeNet Automotive, Predian, Vincue, Dealerslink, Lightspeed, Foureyes, Tekion - Phone system: Volie Demo: https://www.mia.inc/request-a-demo?utm_source=toma _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview Mia handles inbound and outbound phone calls and texts across sales, service, and reception, with multilingual support and 24/7 coverage. Mia reports adoption by over half of the top 10 US dealer groups, and says its high-performing dealers average $800K in added annual revenue from recovered calls. Mia's site lists more than 40 integrations across DMS, CRM, scheduling, inventory, and phone systems; the full set is listed here. --- ### myKaarma _Source: https://www.toma.com/analysis/automotive/mykaarma_ myKaarma's AI agents answer calls and book service inside its own scheduler. It reports 2,000+ rooftops and OEM endorsements including Ford and BMW. #### Integrations - Scheduler: myKaarma Scheduler+ (native) - DMS: CDK, Reynolds & Reynolds, DealerTrack, Automate, Tekion, PBS, DealerBuilt, other majors - OEM programs: VW, Audi, Porsche, Volvo, Lexus, Toyota, Subaru, Stellantis, Nissan, Infiniti, Mercedes-Benz, Mazda, Ford, Kia, Hyundai, Genesis, Honda, Acura, BMW, MINI, Land Rover, Cadillac, GM, Mitsubishi, Ferrari, Lamborghini, Rolls-Royce - Payments: Stripe, Chase Paymentech, CrossCheck, DigniFi, First Data, Global Payments, Heartland, Kount, NMI, TSYS, Worldpay, Cardinal - Communications: Twilio, Autoservice AI, Stella Automotive AI - Loaner & fleet: Dealerware, Logitrac, TSD - Finance: Affirm, Sunbit - Rideshare: Uber - Tire inspection: DealerTire, Hunter, Traxtion, UVeye - Recall: Recall Masters Demo: https://mykaarma.com/request-a-demo/ · (562) 287-5527 _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview myKaarma has run dealership service lanes since 2012, and its AI is built directly into the platform. One system covers the whole service journey: answering calls, scheduling appointments, customer communication, payments, and service updates. The agent captures the customer's concern up front, so technicians diagnose faster, repairs stay accurate, and vehicles keep moving through the shop. The company reports more than 2,000 rooftops, OEM endorsements including Ford, Subaru, and BMW, and an average 37% lift in dollars per repair order. DMS integrations are deep two-way syncs covering customer, vehicle, appointment, and repair-order data. ## Pricing notes myKaarma doesn't publish pricing, and we don't have current numbers. Discuss rates directly at the demo. --- ### Pam _Source: https://www.toma.com/analysis/automotive/pam_ Pam runs voice AI for dealership service and sales and reports 800+ dealers on the platform, with the founding team personally involved in onboarding. #### Pricing Pricing is tailored to each dealer based on the AI agents hired and store configuration. Pam will share exact pricing during the demo. #### Integrations - DMS: Tekion, Reynolds & Reynolds, CDK Global, PBS - Service Schedulers: Xtime, myKaarma, Dealer-FX/WiAdvisor, Affinitiv AutoLoop, RedCap, TCC, Auto.Live, Evenflow - CRM / Lead Management: eLead, Tekion CRM, VinSolutions, DealerSocket Demo: https://pam.ai/toma _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview Pam offers AI agents for inbound calls (service booking, after-hours, overflow, routing) and outbound marketing (voice and text campaigns targeting existing customer lists for service and sales). The platform integrates with major DMS, scheduler, and CRM systems. Pam reports 800+ dealership clients. Contact: abdullah@pam.ai or pam.ai/toma. --- ### ShortLoop _Source: https://www.toma.com/analysis/automotive/shortloop_ ShortLoop trains its phone AI on each store's workflows, books into the DMS and CRM, and starts at $890 a month with modular pricing. **For Toma dealers: a 30-day trial with no setup or installation fee.** #### Pricing Modular by store size, starting at - Starting price: $890/mo (scales up by module and store size) #### Integrations - DMS: Tekion, CDK, Reynolds & Reynolds, DealerTrack, Auto/Mate, PBS - Schedulers: Xtime, myKaarma, DealerFX, DealerTrack - CRMs: VinSolutions, Tekion, Reynolds & Reynolds, PBS, DriveCentric, CDK eLead Demo: https://calendly.com/vish-shortloop/ai-demo · (606) 699-1759 _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview ShortLoop trains its phone AI per store, on that store's own workflows. It handles inbound sales and service calls, books into the DMS and CRM, and runs outbound call and text campaigns across fixed and variable ops. ShortLoop AI supports English and Spanish, and switches between them mid-call. ## Pricing notes Modules run from missed-call handling to AI reception to a full Service BDC, so you can start narrow and add as it proves out. --- ### Stella _Source: https://www.toma.com/analysis/automotive/stella_ Stella manages inbound and outbound across phone, SMS, and email, and books directly into the DMS through certified integrations. #### Pricing Book a demo for pricing and transition incentives #### Integrations - DMS: CDK, Reynolds & Reynolds, Tekion, Automate, PBS - Schedulers: Xtime, myKaarma, Dealer-FX, Update Promise, WiAdvisor - CRMs: Reynolds Focus, VinSolutions - Outbound & BDC: Affinitiv, Volie Demo: https://outlook.office.com/bookwithme/user/41f1a299bbdb43cd93a1fc4f9bb7198b@stellaautomotive.com _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview Stella manages inbound and outbound across phone, SMS, and email, and books appointments directly into your DMS and service scheduler through certified integrations. STELLA Catalyst handles outbound for sales, service, recalls, defectors, telematics, and declined services. --- ### Numa AI _Source: https://www.toma.com/analysis/automotive/numa_ Numa AI runs voice and text for dealership service and sales. Full profile coming soon. Demo: https://numa.com/demo _Information comes from vendor-provided data and public sources, as is; it is not a ranking, endorsement, or recommendation, and Toma accepts no payment for inclusion. Confirm pricing and details with the vendor._ ## Overview We're preparing Numa AI's profile. Sourced facts, pricing, and integrations land here as we confirm them. Contact: jason.hamilton@numa.com. ---