Lifora

Inspiration

University students constantly juggle assignments, exams, personal expenses, limited time, and changing priorities. Most productivity tools handle these areas separately, while general AI assistants usually respond only to whatever information is included in a single prompt. We wanted Lifora to look at a student's situation as a whole and answer one simple question: “Given everything happening in my life right now, what is the smartest thing I should do next?”

That idea became Lifora — an adaptive personal AI operating system. For the hackathon, we focused on University Student Mode, combining academic priorities, personal budgeting, and available time into one intelligent decision-making system.

What it does

Lifora uses multiple specialized agents to analyze different parts of a student's life:

• Academic Agent evaluates assignments, deadlines, progress, remaining workload, and deadline risk.
• Finance Agent evaluates budget, expenses, remaining money, and spending pressure.
• Balance Agent evaluates available time, workload, and whether a proposed schedule is realistic.
• Coordinator Agent compares the specialist recommendations, resolves conflicts, and decides what should be prioritized. Instead of returning only a generic recommendation, Lifora provides:
• Best Next Action
• Daily Plan
• Deadline-Risk Warnings
• Agent Insights
• Decision Trace
• explanations for why other actions were deprioritized Lifora can also re-evaluate its recommendation when the student's state changes. For example, completing more of an assignment, having less available time, or recording a new expense can change the agents' priorities and the Coordinator's final decision.

How we built it

We built Lifora using Jac and the Jaseci ecosystem, with Jac as the main language for the application and JacHammer as part of our development and deployment workflow. Our architecture follows this general pipeline: Persistent Student State ↓ StudentSnapshot ↓ Academic Agent Finance Agent Balance Agent ↓ Coordinator Agent ↓ CoordinatorResult ↓ Lifora Dashboard

We separated deterministic computation from AI reasoning. We use normal program logic for tasks such as:

• budget calculations
• task progress
• deadline comparisons
• available-time calculations
• validation
• deadline-risk logic AI reasoning is used for areas where contextual understanding is more valuable, including:
• comparing competing priorities
• understanding the student's current situation
• resolving conflicts between agents
• explaining the final recommendation We also designed shared structures such as StudentSnapshot, AgentResult, and CoordinatorResult so different parts of the system could be developed independently and integrated through clear contracts.

Challenges we ran into

One of our biggest challenges was scope. Lifora could potentially include career planning, research, courses, events, jobs, and support for different life stages. However, trying to build everything in a one-day hackathon would have resulted in many shallow features. We therefore focused on three domains: Academic + Finance + Balance

Another challenge was making the system genuinely agentic. Running several independent AI prompts would not be enough. We wanted the agents to sometimes disagree and require the Coordinator to make an actual decision. For example, the Academic Agent may recommend several hours of study because of an approaching deadline, while the Balance Agent may determine that the proposed schedule is unrealistic. The Coordinator must then resolve that conflict rather than simply repeating both answers. We also had to work with an evolving Jac ecosystem, understand its full-stack architecture, persistence model, AI capabilities, and JacHammer workflow, and keep the different parts of the project compatible while developing them in parallel.

Accomplishments that we're proud of

We are especially proud that Lifora goes beyond a simple chatbot interface. Our goal was to make the intelligence of the system visible and explainable. The Decision Trace shows how the specialist agents contributed to the final decision, where priorities conflicted, and why the Coordinator selected one action over another. We are also proud of designing Lifora around dynamic replanning. The recommendation is not meant to remain static. When the student's situation changes, Lifora can analyze the updated state and generate a new plan. Another important accomplishment was structuring the project so three team members could work independently on:

• persistent state and backend services
• AI agents and coordination
• frontend and user experience while integrating through shared data contracts.

What we learned

This project taught us that building an agentic AI application is very different from simply adding an LLM to an existing application. We learned the importance of deciding what AI should do and what normal program logic should do. Simple calculations, validation, and hard constraints are more reliable when handled deterministically, while AI is much more useful for interpretation, prioritization, explanation, and resolving softer conflicts. We also learned how important clear contracts are in multi-agent and team-based systems. Defining shared structures before implementation allowed us to work in parallel without every component depending directly on every other component. Working with Jac also gave us experience with an AI-native programming approach, persistent application state, server-side services, agent-oriented workflows, and full-stack development within the same ecosystem.

What's next for Lifora

University Student Mode is only the first stage of Lifora. Our longer-term vision is for the platform to adapt as the user moves through different stages of life: A/L Student ↓ University Student ↓ Intern / Job Seeker ↓ Employee ↓ Career Growth

Future versions could introduce specialized capabilities for learning, career development, research, opportunities, and other priorities while maintaining a persistent understanding of the user's changing goals and responsibilities. We also want to expand the What-If Simulator, allowing users to explore questions such as:

• What if I only have two hours available tonight?
• What if I have an unexpected expense?
• What if I finish an assignment earlier than expected? Lifora could then compare the current situation with the simulated one and explain how and why the recommended action changes. Our long-term goal remains simple: Lifora — One life. Many priorities. One intelligent next step.

Built With

• agentic-ai
• ai
• ai-agents
• app
• decision-support
• dynamic-replanning
• explainable-ai
• full-stack
• graph-based-ai
• jac
• jachammer
• jaseci
• llm
• multi-agent-systems
• persistent-state
• personal-finance
• productivity
• student-productivity
• task-management
• web
• what-if-simulation