UnStuck

• 

  user can enter the problem

• 

  Based on the statu of the problem, agent will suggest next action, Yodha will like an emotional support for the user

• 

  As the user completes the work by clicking done, it gets added to the momentum

• 

  the agent will check the status of their progress

• 

  If the user doesn't get the action done or let the agent know whether it's too hard or stuck, then the agent will check up on the user.

• 

  User can additional update the agent with more context to get more specific instructions

• 

  the agent will use the updated information to then suggest the next best action

• 

  When the user clicks I'm stuck button, the agent will check with the user to understand what's stopping them from taking the action.

Inspiration

UnStuck came from a simple frustration: sometimes the problem is not knowing what to do, but actually starting.

People can get trapped in overthinking, perfectionism, fear of failure, distraction, overwhelm, or even planning endlessly without taking action. Most productivity tools respond by giving users more plans and longer to-do lists. UnStuck was designed around the opposite idea: reduce the friction between intention and action.

What it does

UnStuck is an adaptive anti-procrastination companion that helps users move forward one doable step at a time.

It can:

• ask for context before acting when a goal is too broad
• detect when planning itself is becoming procrastination
• break difficult tasks into smaller actions
• gradually increase action size as momentum builds
• respond differently when users feel overwhelmed, distracted, perfectionistic, afraid of failure, or emotionally stuck (yoda function)
• let users update the agent when their real-world progress changes or when they need to give more context (update me option)
• check in after periods of inactivity
• preserve user agency around high-commitment actions such as sending, submitting, deleting, or purchasing (safety filtering)
• recognise when the original task is complete and stop generating unnecessary steps

How we built it

UnStuck was built in Python using Streamlit for the interface and an LLM for reasoning and structured action generation.

The model returns structured outputs containing information such as the user's goal, likely blocker, clarification needs, next action, action difficulty, expected duration, and task-completion status.

Streamlit session state stores progress across interactions, including completed actions, context updates, inactivity status, and the current task.

We also implemented deterministic logic outside the LLM for:

• planning-loop detection
• inactivity monitoring
• safety filtering
• adaptive action sizing
• task-completion handling

This combination allows the model to reason about the user's situation while the application controls important behavioural and safety constraints.

Challenges we ran into

One of the biggest challenges was deciding how small each action should be.

Early versions decomposed tasks too aggressively. Even after the user had built momentum, the system continued suggesting tiny and sometimes unnecessary steps. We changed the behaviour so that actions become larger as the user succeeds, allowing UnStuck to transition from activation to meaningful progress and eventually completion.

Another challenge was keeping the agent aligned with the user's real-world situation. Users may skip ahead, complete more than expected, or encounter steps the agent did not anticipate. We added an update mechanism so users can correct the agent and continue from where they actually are.

We also encountered the challenge of preserving user agency. The agent should help someone move forward without pushing them into irreversible actions they have not consciously chosen.

Accomplishments that we're proud of

We are proud that UnStuck evolved beyond a simple chatbot or AI-generated to-do list.

The prototype can maintain state across a task, adapt action difficulty, detect planning paralysis, respond to inactivity, handle emotional blockers, accept real-time context updates, and recognise when a goal has been completed.

We are especially proud of the interaction design: instead of showing users a large future workload, UnStuck focuses attention on the next useful action while still adapting to what happens in the real world.

What we learned

Building UnStuck showed us that creating a useful AI application requires much more than a good prompt.

We learned about:

• structured LLM outputs
• stateful AI applications
• adaptive prompting
• Streamlit session management
• safety guardrails
• behavioural interaction design
• inactivity monitoring
• deploying an end-to-end AI prototype

Most importantly, we learned that useful agent behaviour comes from combining model reasoning with application state, deterministic rules, and thoughtful UX.

What's next for UnStuck

The next step is to make UnStuck more proactive and measurable.

Future improvements include:

• WhatsApp or SMS check-ins when a user becomes inactive
• longer-term progress and procrastination-pattern tracking
• personalised action-size adaptation based on previous sessions
• better planning-loop detection
• an evaluation harness for systematically testing blocker detection, action quality, safety, and task progression
• optional integrations with calendars and task-management tools
• a mobile-friendly interface and push notifications

The long-term goal is for UnStuck to become a lightweight action companion that notices when someone is stuck and helps them move again without overwhelming them.

Built With

• agentic-ai
• ai-agents
• ai-safety
• generative-ai
• gpt
• llm
• prompt-engineering
• python
• python-dotenv
• streamlit