CommitCall

• 

  Logo

Inspiration

Most productivity tools stop at sending reminders. They tell us what we planned to do, but they do not ask what actually happened.

We built CommitCall to make accountability more active and personal. Instead of another notification that can be ignored, an AI agent calls the user, asks whether their goal is complete, and adapts based on the answer.

What it does

CommitCall is an Agent Skill for personal accountability check-ins powered by CALL-E.

The user provides their own phone number, goal, region, language, timezone, and result location. Before a call, CommitCall validates the request, checks for duplicates, masks the phone number in previews, and requires explicit approval.

During the call:

• If the user says yes, CommitCall records the goal as complete.
• If the user says no, it asks for the main blocker and when the user will continue.
• If the answer is unclear, it asks once more instead of guessing.
• If the user asks the bot to wait, it remains silent until the user is ready.

The result is reconciled into structured data and stored locally without saving the full phone number or transcript.

How we built it

CommitCall is built as an Agent Skill rather than a standalone application. The workflow is defined in Markdown instructions and references:

• SKILL.md defines the accountability workflow, consent checks, planning, approval, and result persistence.
• dialogue-quality.md defines a conversation state machine to keep the voice interaction short and natural.
• result-schema.json defines the structured result format.
• safety.md defines privacy, self-consent, and duplicate-prevention rules.

The project uses Codex as the agent host and CALL-E for the phone-call workflow. CALL-E plans, runs, and monitors calls through its MCP-compatible tool flow.

Challenges we ran into

A key challenge was making the conversation sound natural. Long instructions can cause fragmented voice delivery, repeated greetings, or multiple questions in one turn.

We addressed this with a dialogue-quality contract: short complete sentences, one question per turn, explicit silence when the user asks the bot to wait, and clear ending behavior for yes, no, and unclear answers.

Another challenge was call safety. A phone call is a real-world side effect, so CommitCall separates planning, preview, approval, execution, monitoring, and result persistence. It also prevents duplicate calls and only supports self-calls.

Accomplishments that we're proud of

• Created a reusable adaptive accountability Agent Skill.
• Designed a structured result contract for completed and incomplete goals.
• Added explicit self-consent and masked phone-number previews.
• Added duplicate prevention and one-call-only execution safeguards.
• Built a conversation state machine for yes, no, unclear, and wait states.
• Successfully tested an end-to-end self-call.
• Recorded a clear affirmative answer as {"completed": true}.
• Ensured that the local result log does not store full phone numbers or transcripts.

What we learned

We learned that a useful voice agent needs more than a good prompt. It needs clear turn-taking, silence rules, result reconciliation, privacy boundaries, and explicit approval before taking action.

We also learned that provider integration details matter. A skill, MCP tools, authentication, and CLI execution need to work together reliably before a voice workflow can be safely demonstrated.

What's next for CommitCall

Next, we plan to:

• Complete the direct integration between CommitCall and the official CALL-E CLI workflow.
• Test the incomplete-goal and unclear-answer branches more extensively.
• Improve voice pacing and reduce fragmented delivery.
• Support recurring accountability check-ins through safe scheduler composition.
• Add integrations with task-management tools while preserving privacy and consent.

Built With

• call-e
• codex
• github
• mcp