ActionBridge AI — Adaptive Personal Action Agent

An AI agent that remembers your commitments, adapts when plans change, and safely replans with your approval.

Comment

Inspiration

People make commitments everywhere: assignments, quizzes, meetings, presentations, appointments, and personal goals. The problem is not simply remembering them. The real difficulty begins when something changes.

If a deadline moves, a traditional reminder or task manager may update that single date, but it does not necessarily understand how the change affects the rest of the user's plan.

We built ActionBridge AI around a simple question:

What if an assistant could remember your commitments, understand how a change affects your existing plan, propose a safe adaptation, and wait for your approval before taking action?

That became our core workflow:

Understand → Remember → Reason → Act → Adapt

ActionBridge AI is a persistent personal action agent, built as a simulated Alexa+ agentic experience in a web application.

What it does

ActionBridge turns natural-language commitments into a persistent, actionable plan.

A user can tell the agent:

"I have a Statistics quiz on October 29, an AI assignment on October 30, and a presentation on October 31."

ActionBridge stores those commitments and creates a plan around them.

The important part happens when circumstances change.

If the user later says:

"My AI assignment deadline changed from October 30 to October 28."

ActionBridge does more than replace one date. It identifies the affected commitment, checks the existing schedule for conflicts and pressure, and generates a targeted replan.

Before anything changes, the user sees the proposed update and must explicitly approve it.

This creates a human-in-the-loop workflow:

Change detected → Impact analyzed → Replan proposed → Human confirms → Changes applied → Updated plan remembered

The user's commitments and approved plan persist in SQLite, allowing ActionBridge to maintain useful context across sessions.

How we built it

ActionBridge uses a layered agentic architecture.

The frontend is built with React, Vite, and TypeScript, while FastAPI provides the backend API.

At the center is the ActionBridge agent, which runs a bounded multi-round tool-use loop and communicates with an in-process Model Context Protocol (MCP) server.

We expose only five safe model-facing MCP tools:

  • create_commitment
  • get_commitments
  • create_plan
  • detect_conflicts
  • propose_replan

Planning, conflict detection, persistence, and application of approved changes are handled deterministically in the service layer.

We deliberately do not expose apply_changes or cancel_change to the model. Applying or cancelling a proposed change requires a separate HTTP request triggered by the user's action in the interface.

This means the AI can reason and propose, but it cannot silently modify the user's plan.

For persistence, we use SQLite with commitments, plan items, and pending changes.

We also implemented a provider abstraction supporting Amazon Bedrock, Google Gemini, and a deterministic reviewer/demo provider while preserving the same agent, MCP, service, persistence, and confirmation architecture.

Challenges we ran into

One of our biggest challenges was making the system agentic without making it unpredictable.

Scheduling and replanning involve operations that should not depend entirely on free-form model output. We therefore separated responsibilities: the provider helps interpret intent and orchestrate tools, while deterministic Python services handle scheduling, conflict detection, diffs, persistence, and state mutation.

Another important challenge was safe action execution. We wanted ActionBridge to adapt plans, but we did not want a model to directly apply consequential changes. This led to our human-confirmation boundary: the agent can create a pending proposal, but only the user can approve or cancel it.

We also encountered external provider constraints during development. Our Amazon Bedrock integration successfully reached AWS through the Converse/tool-calling architecture, but final testing encountered account/runtime token throttling. Our Gemini integration was also exercised successfully before later encountering provider quota limits.

To make the project reliably reproducible for reviewers, we created a deterministic no-key Demo Mode. It runs through the same agent, MCP tools, deterministic services, SQLite persistence, and human-confirmation workflow without requiring external API credentials.

What we learned

This project taught us that building an effective agent is not just about connecting an LLM to tools.

We learned the importance of:

  • separating probabilistic reasoning from deterministic operations;
  • designing strict tool boundaries;
  • maintaining state across interactions;
  • validating dates and schedule changes;
  • handling provider failures without compromising the core product;
  • making AI actions explainable before execution; and
  • keeping humans in control of state-changing operations.

We also gained practical experience with MCP tool calling, FastAPI, React, persistent agent state, SQLite, Amazon Bedrock, Gemini, testing, and agent safety design.

Accomplishments that we're proud of

We are especially proud that ActionBridge is more than a conversational prototype.

It has a working end-to-end loop:

Natural language → persistent commitment → plan → change detection → impact analysis → proposed replan → human confirmation → persistent update

The model-facing agent has only five safe tools, while applying and cancelling changes remain outside the model's control.

Our final backend suite passes 236 tests, and the frontend passes its TypeScript and Vite production build.

Most importantly, ActionBridge demonstrates our original idea: an assistant should not just know that something changed. It should understand what that change affects and what should happen next.

What's next for ActionBridge AI

Our next step would be connecting ActionBridge to real productivity services such as calendars, reminders, task managers, and communication platforms.

We would also like to expand the planning engine to support richer priorities, dependencies, travel time, recurring commitments, and multi-user coordination.

With deeper Alexa+ integration, the same workflow could become a natural voice experience: users could make commitments conversationally, ask what to focus on, change plans through voice, and approve proposed adaptations before they are applied.

Our long-term goal is for ActionBridge to become an assistant that does not simply answer questions, but helps people reliably follow through as their real-world plans change.

Built With

Share this project:

Updates

Submission history