Inspiration
Businesses already know why they need to contact their customers. They also already have the data.
The problem is everything in between.
Customer information lives in spreadsheets that rarely match the structure of the software receiving it. Outreach workflows have to be configured. AI agents need clear authority boundaries. Calls need to produce something operationally useful when they end.
We built MacroDial to connect those pieces.
The idea became:
Describe the business → understand the data → govern the conversation → execute the call → turn the result into action.
What it does
MacroDial is a governed AI customer-outreach platform built around CALL-E.
Rather than requiring an operator to manually configure every part of an outreach system, MacroDial uses AI at the points where it can remove the most work while keeping consequential actions under explicit operator control.
Auto Config
An operator can describe a business in plain English.
MacroDial analyzes that description and proposes an operating model including services, essential customer fields, outreach workflows, playbooks, outcomes, and authority boundaries.
The operator reviews the proposal before anything changes.
Generation, applying configuration, activating a playbook, scheduling outreach, and enabling calling remain separate decisions.
Smart Data Loader
Real business spreadsheets are messy.
Instead of forcing users to rebuild their data around MacroDial, we built the Smart Data Loader to understand the spreadsheet.
For our deployed acceptance test, we deliberately shuffled columns and changed their names to ordinary business terminology.
MacroDial automatically mapped 14/14 fields:
- 8 deterministic mappings
- 6 semantic/LLM mappings
- 0 critical ambiguities
- No manual field mapping required
The loader also recognizes existing records and duplicate appointments rather than blindly creating them again.
A fictional test import successfully produced 10 customer writes and 10 appointments with zero actual failures.
Governed CALL-E execution
Importing a phone number does not authorize MacroDial to call it.
Execution is separated from ingestion.
Outreach requires the appropriate playbook, purpose, authority, recipient, schedule, and execution controls.
CALL-E then handles the actual phone interaction and returns a structured result that MacroDial can validate and use to update operational state.
During final acceptance we performed one explicitly authorized TEST/UAT call.
The result:
1 authorized recipient → 1 completed CALL-E interaction → validated structured outcome → persisted state transition
The customer expressed interest, and MacroDial moved the test outreach from:
SCHEDULED → INTEREST CONFIRMED
The customer master and unrelated history remained unchanged, and the live-call controls were returned to OFF after the test.
How we built it
MacroDial is a browser-based application with a governed backend workflow connecting business configuration, customer data, playbooks, scheduling, CALL-E execution, and persisted results.
We built the system around a few principles:
- AI should remove configuration work, not operator accountability.
- Messy data should be understood rather than forcing the user to rebuild it.
- Data ingestion and permission to communicate should remain separate.
- AI-generated configuration should be reviewable before mutation.
- A conversation should return structured information that can drive the next operational state.
Auto Config combines structured validation with LLM-assisted generation.
Smart Data Loader uses deterministic mapping when a field can be confidently recognized and semantic/LLM mapping for unresolved business-language fields.
CALL-E provides the phone execution layer.
MacroDial surrounds that execution with playbook authority, scheduling, recipient controls, result validation, persistence, and an audit trail.
We also created a portable MacroDial reference application for the CALL-E ecosystem demonstrating the governance and state-transition concepts without requiring credentials, customer data, or outbound calls.
Challenges we faced
The hardest problems were not simply getting an AI to generate text or getting a phone call to connect.
They were the boundaries between systems.
Real spreadsheets are unpredictable
Our automated tests initially passed while a real XLSX workbook failed because different spreadsheet writers serialized strings differently.
Browser UAT exposed the issue.
We expanded the parser to normalize multiple valid XLSX representations and then pushed further: instead of merely accepting our template, the loader needed to understand spreadsheets that did not look like our template at all.
That evolved into the Smart Data Loader.
Configuration intelligence is not enough if the UX exposes the machinery
Our first Auto Config implementation could generate and apply playbooks, but the operator experience still exposed too much internal configuration.
We redesigned the workflow around a much simpler concept:
Tell MacroDial about your business.
The system now produces a human-readable proposal that can be inspected before applying it.
AI needs boundaries
We deliberately tested Auto Config using a veterinary clinic even though our existing configuration was oriented around HVAC.
That forced the system to reason about a materially different business and generate restrictions such as not diagnosing animals, recommending medication, or making unauthorized commitments.
That exercise reinforced an important lesson:
The interesting question is not only what an AI agent can do. It is how clearly we can define what it may and may not do.
Proving the complete loop
A simulated call was not enough for final acceptance.
We performed a controlled real CALL-E test using one explicitly authorized recipient and an isolated TEST/UAT outreach record.
CALL-E completed the interaction, returned a structured result, MacroDial validated it, and the resulting state persisted.
That was the moment the architecture became a complete loop rather than a collection of features.
What we learned
One of the biggest lessons from MacroDial was that AI becomes more useful when it is surrounded by deterministic systems.
We use intelligence where ambiguity exists:
- Understanding a business
- Interpreting unfamiliar spreadsheet fields
- Conducting a conversation
We use deterministic controls where ambiguity is dangerous:
- Validation
- Duplicate detection
- Authority
- Scheduling
- Authorization
- State transitions
- Persistence
- Auditability
That combination became the design philosophy of MacroDial:
Intelligence where it removes work. Controls where they prevent harm.
What's next
MacroDial started as an AI calling workflow and grew into something broader.
Auto Config showed us that business software can increasingly configure itself from intent.
Smart Data Loader showed us that users should not have to restructure their information just to satisfy an application's schema.
CALL-E demonstrated how those capabilities can ultimately produce real-world action.
The next step is continuing to expand the businesses and workflows MacroDial can understand while preserving the governance model that makes autonomous execution practical.
Describe the business. Understand the data. Control the conversation. Close the loop.
Log in or sign up for Devpost to join the conversation.