Call Neuron

Scholarship outreach, powered by human follow-up.

Comment

Inspiration

Scholarship and education-support teams may already have a consented outreach list, but reaching every household respectfully is difficult. Staff must contact the correct adult, explain an opportunity consistently, protect student information, record questions, respect opt-outs, and still provide sincere human follow-up.

Call Neuron began with one question:

How can phone automation expand access to opportunity without making outreach careless, intrusive, or impersonal?

The answer was not to replace scholarship officers. It was to automate the repetitive first conversation while keeping eligibility, awards, exceptions, and follow-up firmly in human hands.

What it does

Call Neuron is a consent-first scholarship outreach agent powered by CALL-E. It helps an operator prepare one approved opportunity brief, review one consented adult recipient, create a no-call plan, and explicitly confirm one real outbound call.

The workflow supports:

  • manual recipient entry or local import from CSV, XLSX, DOCX, and selectable-text PDF files under 50 MB;
  • validation of student or employee codes, E.164 phone numbers, adult recipient details, and consent evidence;
  • four explicit consent checks before a call can be prepared;
  • a reviewable CALL-E plan that cannot ring a phone;
  • a separate final confirmation before one call is placed;
  • a polite introduction that names the organization, explains the reason for calling, discloses processing and transcription, and asks permission to continue;
  • identity confirmation before student or opportunity details are revealed;
  • answers limited to the approved brief, with unknown questions escalated to a human;
  • interest, questions, callback preferences, opt-outs, and follow-up dispositions; and
  • an optional privacy-safe voicemail containing only the organization and public callback number.

Call Neuron never ranks students, decides eligibility, promises an award, collects payment, or retries a call automatically.

Try the live Call Neuron prototype or review the open-source CALL-E contribution.

How we built it

I built Call Neuron individually with React, TypeScript, Vite, IndexedDB, Web Crypto API, and Cloudflare Pages. CALL-E is integrated through MCP and is actually invoked at runtime.

The integration separates planning from execution:

await initializeCallE();
await verifyRequiredTools(["plan_call", "run_call", "get_call_run"]);

const plan = await planCall(reviewedRecipient); // Cannot ring a phone.
await requireExplicitHumanConfirmation(plan);

const acceptedRun = await runCall(plan);
await persistAcceptedRunId(acceptedRun.id);

The CALL-E lifecycle is:

  1. initialize establishes the MCP connection.
  2. tools/list verifies the required CALL-E tools.
  3. plan_call produces a reviewable no-call plan.
  4. run_call executes only after explicit human confirmation.
  5. get_call_run monitors the same accepted run.

Recipient documents are parsed locally in the browser; Call Neuron does not upload the original file. Campaign rows and human dispositions are stored in IndexedDB, while CALL-E access tokens, confirmation secrets, imported documents, and transcripts are not persisted in the dispatch-safety ledger.

Safety by design

A content-bound reservation ties the recipient to the exact approved offer and voicemail setting. Dispatch follows a durable state machine:

$$ \text{planning} \rightarrow \text{planned} \rightarrow \text{dispatching} \rightarrow \text{accepted} $$

If CALL-E may have accepted a call but the response is lost, the system enters:

$$ \text{dispatching} \rightarrow \text{acceptance_unknown} $$

The governing rule is simple:

$$ \text{uncertain acceptance} \Rightarrow \text{no automatic retry} $$

In plain language, the permitted retry count is \(0\) whenever acceptance is ambiguous. The unresolved record cannot be discarded; the operator must reconcile it against CALL-E provider records.

Cross-tab updates use BroadcastChannel, and a stable recipient fingerprint prevents re-importing the same person to bypass an existing dispatch lock.

Challenges we ran into

Making the call sound respectful

The early conversational behavior was too abrupt and asked too few questions. I refined the CALL-E instruction so the caller introduces itself clearly, explains the purpose, requests permission, listens patiently, invites questions, and accepts rejection without pressure.

If someone is interested, the agent explains that a human staff member will contact them shortly and asks what they would like that person to clarify.

Preventing duplicate calls

Initially, accepted run IDs and attempt state existed only in React memory. A refresh or second tab could make a recipient appear callable again. I replaced that behavior with atomic, durable reservations and accepted-run recovery.

Balancing privacy with recovery

Persisting everything would retain unnecessary sensitive information. Persisting nothing would make duplicate prevention unreliable. Call Neuron stores only the minimum operational evidence needed for safety: content hashes, dispatch phase, plan ID, accepted run ID, provider status, and timestamps.

Building with zero budget

The prototype uses Cloudflare Pages, browser-local storage, open-source libraries, and the free CALL-E calls available to new accounts. It requires no paid database, analytics platform, font service, custom domain, or background worker.

Accomplishments that we're proud of

Call Neuron is a complete operational workflow rather than a generic “AI that makes phone calls” demo. Its implementation includes:

  • real CALL-E MCP integration at runtime;
  • consent and identity gates;
  • one reviewed recipient and one confirmation per call;
  • no batch dispatch or automatic retry;
  • optional privacy-safe voicemail;
  • four supported local import formats;
  • refresh-safe and cross-tab duplicate prevention;
  • fail-closed ambiguous acceptance;
  • accepted-run recovery for same-run status checks;
  • dispatch-time opt-out enforcement; and
  • privacy-minimal CSV export for human follow-up.

The project passes TypeScript validation, 17 automated tests, a production build, repository validation, and a headed browser workflow test. The automated suite uses a fake CALL-E broker and fictional reserved data, so verification cannot place a real call.

What we learned

A responsible phone agent is not defined only by whether it can complete a call. It must also answer:

  • Should this person be contacted?
  • What may be disclosed before identity is confirmed?
  • Does consent cover automation, processing, and transcription?
  • Who owns the decision after the call?
  • What happens when a network response is lost?
  • Can the system prove it will not retry unexpectedly?

Consent is not one checkbox, and safety cannot live only in interface copy. Consequential rules must be enforced in runtime behavior and persistence.

Most importantly, automation should create a clearer path to human support—not remove humans from the process.

What's next for Call Neuron

Next, I would add organization accounts, operator roles, shared do-not-call records, configurable calling-hour policies, human follow-up assignment, webhook-based CALL-E status updates, multilingual scripts reviewed by native speakers, scholarship CRM integrations, and provider-supported idempotency keys.

The long-term goal is to help education organizations reach more eligible, consented recipients while keeping privacy, consequential decisions, and sincere follow-up firmly under human control.

Built With

  • call-e
Share this project:

Updates

Submission history