DEV Community: Jordan Autrey

Day 2: Building an AI Real Estate Company That Makes Its Own Phone Calls

Jordan Autrey — Thu, 19 Mar 2026 20:03:38 +0000

Yesterday I launched The Hive publicly — a multi-agent AI system running on my Mac Studio M4 Max — with Warren B making paper trades on Alpaca and Felix RE starting to scout distressed properties. Day 1 was about getting agents live. Day 2 was about giving one of them a voice and a real company behind it.

Introducing Abode AI Incorporated

Today I formally spun up Abode AI Incorporated — an AI-first real estate solutions company. The flagship product is Liam Pryor, an AI voice agent who makes outbound cold calls, handles inbound callbacks, books follow-up appointments, and processes his own transcripts.

Liam runs on ElevenLabs Conversational AI + Twilio for the actual phone infrastructure. The personality prompt was built by stacking three philosophies on top of each other:

Ryan Serhant's relationship-first sales — leads with curiosity, never desperation
Alex Hormozi's value equation — every interaction is a value exchange, not a pitch
Win Without Pitching Manifesto — never sell, just explore problems

The result is an agent that doesn't sound like a robot dialer. He sounds like a sharp acquisitions guy who genuinely wants to understand your situation before ever mentioning a number.

How Liam Makes a Call

When Felix RE identifies a distressed property lead, it packages the context and passes it to the voice engine. Here's what gets injected into the ElevenLabs dynamic_variables payload before each call:

const dynamicVars: Record<string, string> = {
  owner_name: lead.ownerName,
  address: expandAddress(lead.address),
  city: lead.city,
  state: lead.state,
  call_type: lead.callType,            // "cold" | "follow-up" | "pre-foreclosure"
  requires_recording_disclosure: "true",
  investor_name: "Abode AI",
  company_name: "Abode AI",
};

// The secret sauce — municipal distress data injected per lead
if (lead.distressContext) {
  dynamicVars.distress_signals = lead.distressContext;
}

That distress_signals variable is what makes this different from every other AI dialer out there.

Post-Call: Groq Classifies Every Transcript

After the call ends, the transcript comes back from ElevenLabs. I pipe it through Groq (Llama 3.3 70B, runs in ~1 second) with a structured classification prompt:

"outcome": "interested" | "not_interested" | "callback_scheduled" |
           "no_answer" | "voicemail" | "wrong_number" | "dnc_request"

If the outcome is callback_scheduled, the system resolves relative times ("call me back Tuesday around this time") into absolute ISO 8601 datetimes and automatically creates a Google Calendar event — so I have a human-readable record even if I never touch the dashboard. Then it re-queues the lead for Liam to auto-call at that exact time.

DNC requests are handled immediately and atomically — the number hits a local JSON blocklist before the function returns.

The Distress Signal Pipeline

The real moat here isn't the voice agent. It's the data feeding into it.

Every night at 1 AM, a scraper pipeline hits 6 public municipal portals across three markets:

Market	County	Signals
Atlanta	Fulton County	Code violations, tax delinquency
Memphis	Shelby County	Code violations, tax delinquency
Indianapolis	Marion County	Code violations, tax delinquency

The pipeline: run each scraper sequentially (rate-limit polite), upsert raw signals into SQLite, run an enrichment pass to normalize addresses and match signals to active pipeline leads, then write a distress-signals.md file into each lead's folder.

Total monthly cost: /bin/zsh. All public records. All open-source tools (Puppeteer, SQLite, Node.js).

When Liam calls a homeowner with an open code violation, he already knows about it. That's not a magic trick — it's just doing the research before picking up the phone.

The Debug That Wasn't a Bug

Spent a few hours today troubleshooting voice agent instability. Liam kept cutting himself off mid-sentence. I tuned turn eagerness, adjusted silence timeouts, toggled speculative turn detection — nothing worked.

Turned out it wasn't a configuration issue at all. It was ElevenLabs error 1002 — quota exceeded on the free tier. The agent was failing silently at the API layer, not at the conversation layer.

Lesson: when a voice agent behaves erratically, check API quota before touching model settings.

What's Next

Day 3:

Launch the Abode AI landing page (built with Lovable, already prompted)
Upgrade to ElevenLabs paid plan — unlock the quota ceiling
First real calls to actual homeowners using live pipeline leads
Warren B transitions from paper trading to evaluating real position sizing

The infrastructure is ready. Tomorrow we find out if homeowners pick up.

Building The Hive in public. All code is TypeScript, all inference is local (Ollama + LM Studio + Groq). Questions or thoughts — drop them in the comments.

Why I Built a Local-First Voice-to-Code Tool (And What 18 Days of $0 Revenue Taught Me)

Jordan Autrey — Wed, 18 Mar 2026 20:47:51 +0000

Why I Built a Local-First Voice-to-Code Tool (And What 18 Days of $0 Revenue Taught Me)

I'm going to be honest with you: I'm writing this post from $0 MRR on day 18 of building Voco V2.

Not because I don't have a product. The product works. The architecture is solid. The latency is sub-300ms. Everything runs local.

I'm at $0 because I spent 18 days building instead of selling. This post is me fixing that.

The Problem Nobody Talks About

Every AI coding assistant — GitHub Copilot, Continue, Kiro, Cursor — expects you to type your prompts. You're using an AI to write code faster, but you're still bottlenecked by a keyboard.

For most developers, that's a minor friction. For developers with RSI, carpal tunnel, or limited mobility, it's a wall.

And even if your hands are fine today, the average software engineer types 5,000-10,000 keystrokes per hour. Over a career, that adds up. According to research, RSI affects a significant percentage of professional programmers.

What Exists Today

The voice coding space isn't empty. There are real tools doing real work:

Talon Voice — incredible for full hands-free computer control. Built by Ryan Hileman after he developed severe hand pain. But it has a steep learning curve and requires significant setup.
Wispr Flow — fast, polished dictation. But it's cloud-based (your audio leaves your machine) and built for prose, not code.
SuperWhisper — solid local transcription. But it's a general-purpose tool, not optimized for code syntax.
Claude Code Voice Mode — just launched, push-to-talk in terminal. Cool, but limited to Claude's ecosystem.

Each of these is good at what it does. None of them are built specifically for the workflow of speaking code into existence with local-first privacy as a non-negotiable.

What We Built

Voco V2 is voice-to-code. Not voice-to-text-that-you-paste-into-code. Voice to working code.

The key specs:

Sub-300ms latency — speak and see code appear, not "speak, wait 2 seconds, see code appear"
Fully local — your audio never leaves your machine. No API keys, no cloud calls, no telemetry. The model runs on your hardware.
Zero-trust architecture — we literally can't see your data because it never reaches us
Built for code — understands syntax, function signatures, variable names. Not optimized for writing emails.
Zero config — no grammar files to write, no training period, no custom commands to memorize

The Architecture Decision That Changed Everything

Early on, we had to make a choice: cloud or local?

Cloud is easier. You get access to massive models, the transcription quality is higher out of the box, and you don't have to worry about hardware requirements.

We chose local anyway. Here's why:

Privacy isn't optional for developers. You're speaking your code out loud. That includes function names, business logic, API endpoints, proprietary algorithms. Sending that to a cloud service is a non-starter for any serious engineering team.
Latency compounds. Even 500ms of network round-trip feels wrong when you're in flow. Sub-300ms local processing means voice coding feels like typing, not like dictating.
No dependency = no risk. Cloud services go down. APIs get deprecated. Pricing changes. Your local tool works on an airplane.

What 18 Days of $0 Taught Me

Here's the uncomfortable truth I'm sharing publicly because I think other builders need to hear it:

I built a working product, solid infrastructure, automated pipelines, monitoring dashboards, a content engine, and a campaign framework — and generated exactly zero revenue.

Why? Because I never talked to a single potential customer.

I told myself I was "building the foundation" and "getting ready to launch." In reality, I was hiding behind code because shipping to production is comfortable and selling is not.

The infrastructure isn't the product. The sale is the product.

So here I am. Day 18. Talking to people.

The Ask

I'm looking for 10 founding members for Voco V2.

$39/month — founding rate, locked forever. That means if we raise prices later (and we will), yours stays at $39.

What you get:

Full access to Voco V2
Direct access to me (the founder)
Priority feature requests — your voice literally shapes the roadmap
A seat at the table of something we're building from scratch

Who this is for:

Developers dealing with RSI, carpal tunnel, or any repetitive strain
Anyone who codes on mobile and wants a faster input method
Developers who want to try voice-first coding without a week of setup
Privacy-conscious builders who won't send their code to the cloud

Who this is NOT for:

People who want a general dictation tool (use Wispr Flow)
People who need full computer control by voice (use Talon)
People who are happy with their current coding speed and input method

Try It

Website: itsvoco.com

I'm not hiding behind a waitlist. The product exists. You can use it today.

If you have questions, drop them in the comments. I'll answer every single one.

Building in public means showing the messy parts too. Day 18, $0 MRR, and I'm just now doing what I should have done on day 1 — talking to people who might actually want this.

If you're an indie hacker reading this and you recognize the pattern... stop building. Start selling.