DecisionPilot

DecisionPilot — Handles the small digital decisions you don't have time for.

Comment

Inspiration

We realized that a lot of digital stress doesn't come from big tasks. It comes from small decisions that keep piling up, whether to cancel a subscription, archive an email, delete old files, or deal with a reminder.

We wanted to see if an AI agent could take some of those decisions off our hands without blindly doing everything we ask it to do.

What it does

DecisionPilot watches for routine digital decisions and handles the ones it is confident about.

It can:

  • Identify incoming digital signals such as subscriptions, emails, files, and reminders.
  • Automatically resolve safe, obvious decisions.
  • Bring uncertain or personal decisions to the user.
  • Record the user's decision as a preference.
  • Use that preference to handle similar decisions automatically in the future.
  • Keep an audit trail of what the agent did.

The key idea is simple: the more decisions you make, the less often you should have to make the same decision again.

How we built it

We built DecisionPilot with Python and the Strands Agents SDK.

The system uses a small team of agents with different responsibilities. An orchestrator coordinates the process, a classifier evaluates signals, an executor handles approved actions, and a preference learner records patterns from user decisions.

For the hackathon, we used local synthetic data instead of real accounts or external services. This allowed us to focus on the agent's learning loop while keeping all actions safe and simulated.

The core loop is:

Observe → Understand → Decide → Act or Ask → Learn → Reuse

We also built a dashboard to make the agent's decisions visible instead of hiding everything behind a chat interface.

Challenges we ran into

The hardest part was deciding when the agent should act and when it should ask.

An agent that asks about everything isn't very useful. An agent that acts on everything isn't trustworthy either.

We had to design the system around confidence, user preferences, and clear boundaries so that routine decisions could be automated while uncertain decisions remained under human control.

We also had to keep the project realistic within the hackathon timeframe, so we chose a local-first approach rather than spending our time integrating multiple external services.

Accomplishments that we're proud of

The part we're most proud of is the learning loop.

A decision can start as something the agent doesn't know how to handle. The user makes the decision once, DecisionPilot learns from it, and a similar situation can then be handled automatically.

That turns the agent from a simple classifier into something that gets more useful through interaction.

We also built the project so that automated actions are recorded in an audit log, making it clear what the agent did.

What we learned

We learned that building an agent is less about making an AI that can do everything and more about giving it the right boundaries.

The most useful behaviour came from combining autonomy with human judgment: let the agent deal with predictable decisions, but give the user the final say when the decision is personal or uncertain.

We also learned that a good agent should not just remember information. It should use what it learned to change what it does next.

What's next for DecisionPilot

The current version uses synthetic local signals to demonstrate the core idea. The next step is connecting DecisionPilot to real digital environments such as email, calendars, subscriptions, and file systems.

We also want to improve its preference learning, add stronger safeguards around sensitive actions, and eventually allow users to define their own rules for what DecisionPilot can handle automatically.

The long-term goal is simple:

You make a decision once. DecisionPilot remembers it, so you don't have to keep making it.

Built With

Share this project:

Updates

Submission history