LoopPilot — The Agent That Closes Open Loops

An autonomous AI agent that finds unfinished commitments, completes safe routine work, and asks humans only when a real decision is needed.

Comment

LoopPilot — The Agent That Closes Open Loops

The Problem

Modern work is full of small commitments that are easy to create and surprisingly difficult to finish.

“Send the document tomorrow.”

“Confirm the attendee count.”

“Follow up with the sponsor.”

“Reschedule the meeting.”

“Update the tracker after the call.”

None of these tasks are particularly difficult. The problem is that they are scattered across emails, calendars, documents, spreadsheets, and conversations. People have to repeatedly remember what they promised, find the relevant context, decide what to do next, and manually execute it.

Traditional productivity tools help people track these tasks.

We wanted to build something that could actually finish them.

Our Solution

LoopPilot is an autonomous AI agent that discovers unfinished commitments, determines what needs to happen next, completes safe routine work, verifies the result, and only interrupts the human when a meaningful decision is required.

Instead of giving people another task manager to maintain, LoopPilot works in the background toward completed outcomes.

Its core idea is simple:

Don't manage the task. Close the loop.

For example, imagine an event organizer receives an email asking for the final attendee count.

LoopPilot can:

  1. Detect that this is an unfinished commitment.
  2. Search the relevant registration data.
  3. Check the calendar and event context.
  4. Determine the current attendee count.
  5. Prepare the appropriate response.
  6. Evaluate whether the action is safe to execute automatically.
  7. Ask the human for approval when judgment is required.
  8. Send the response.
  9. Update the event tracker.
  10. Verify that the loop has been completed.

The human doesn't have to manually coordinate every step.

Designed Around Useful Autonomy

We did not want to build an agent that blindly acts on everything.

LoopPilot uses a Decision Guard before external actions.

Every proposed action is evaluated using factors such as:

  • confidence in the information
  • potential impact
  • reversibility
  • sensitivity of the data
  • whether the action affects another person
  • whether human judgment is required

Low-risk actions can happen automatically.

Higher-risk actions are escalated.

For example:

Automatically handled

  • Create reminders
  • Update task states
  • Organize information
  • Prepare routine follow-ups
  • Update internal trackers

Human approval required

  • Send an important external communication
  • Change a meeting
  • Share sensitive information
  • Perform a consequential action

This gives LoopPilot a practical autonomy model:

Act when it is safe. Ask when it matters.

Why We Built It

We were inspired by a simple observation:

People rarely lose productivity because they cannot perform a five-minute task.

They lose productivity because hundreds of five-minute tasks remain unfinished, waiting for context, follow-up, approval, or coordination.

The real challenge is not generating another answer.

It is moving from:

“I need to do this.”

to:

“This is done.”

LoopPilot is designed around that transition.

How We Built It

LoopPilot is built using the Strands Agents SDK and AWS services.

At the center is a Strands-based agent orchestrator that coordinates reasoning, tool usage, action execution, and verification.

The system is organized around three major responsibilities:

1. Loop Detector

The Loop Detector identifies unfinished commitments from contextual information such as emails, calendars, task records, documents, and event data.

Each detected loop is represented with structured information such as:

  • what remains unfinished
  • who owns it
  • the deadline
  • the expected next action
  • confidence
  • risk level

2. Action Agent

The Action Agent determines which tools are required to complete the next step.

The prototype exposes tools representing common productivity operations such as:

  • email
  • calendar
  • task management
  • document retrieval
  • event tracking
  • reminders
  • follow-ups

The goal is not to make the agent conversational.

The goal is to give it the ability to do useful work.

3. Decision Guard

Before an external action is executed, the Decision Guard evaluates whether the action should be:

AUTO-EXECUTED

or

ESCALATED TO A HUMAN

This provides a boundary between autonomous execution and human control.

We also use structured outputs and agent lifecycle hooks to make decisions observable and to validate tool execution.

AWS Architecture

The architecture is designed around AWS services that support an agentic workflow.

  • Amazon Bedrock — foundation model and reasoning
  • Strands Agents SDK — agent orchestration and tool use
  • Amazon Bedrock AgentCore Runtime — agent execution and deployment
  • AgentCore Memory — persistent context across sessions
  • Amazon S3 — document and evidence storage
  • Amazon DynamoDB — open-loop state and execution history
  • AWS Lambda — supporting backend operations

AgentCore gives the architecture a path from a local prototype toward a production-oriented agent runtime.

What Makes LoopPilot Different

There are already thousands of AI assistants that wait for a prompt and return an answer.

LoopPilot starts somewhere different:

unfinished work.

Instead of:

User → Prompt → AI → Answer

LoopPilot follows:

Environment → Detect Open Loop → Gather Context → Plan → Assess Risk → Act → Verify → Close Loop

That shift is the core of our project.

We are not building another chatbot.

We are building an outcome-completion agent.

What We Learned

Building LoopPilot changed the way we think about agentic systems.

Our biggest lesson was that autonomy should not be measured by how many actions an agent can take.

It should be measured by how much useful work it can complete without creating new problems for the human.

This led us to focus heavily on:

  • clear tool boundaries
  • structured decisions
  • confidence and risk
  • human approval
  • verification after execution
  • traceable agent actions

We also learned that a narrow, reliable workflow is more valuable than a large collection of loosely connected AI features.

Challenges

The hardest part was not getting an AI model to call tools.

The harder problem was deciding when it should not call them.

An agent that can send an email is easy.

An agent that understands when sending that email is appropriate, when it needs approval, and how to verify the outcome is much more useful.

Designing that boundary became one of the most important parts of LoopPilot.

What's Next

The current prototype focuses on a controlled productivity environment so that the complete agent workflow can be demonstrated reliably.

The next step would be deeper integration with real-world systems such as email, calendars, project-management platforms, and organizational workflows.

Over time, LoopPilot could evolve from closing individual open loops to managing entire recurring workflows for professionals, creators, students, small businesses, and community organizations.

Final Thought

People don't need another place to write down what they still have to do.

They need help getting those things done.

LoopPilot closes the loop.

Built With

Share this project:

Updates

Submission history