MatChalendar

Landing Page
Planner
Food Planner
Energy and Footprint
Other Panels
AgentVerse

Inspiration

College students don’t ignore sustainability — they just don’t have the bandwidth to act on it in daily life.

Most students are already overloaded. Between classes, deadlines, club meetings, meals, workouts, commuting, sleep, and constantly shifting energy levels, even basic daily decisions can become overwhelming. When life gets busy, people naturally default to convenience: taking an Uber instead of walking, ordering delivery instead of checking dining options, skipping recovery time, or choosing meals quickly without considering nutrition or carbon impact.

The problem is not awareness. Students already know sustainability matters. The real problem is execution.

Sustainable choices usually require extra planning, extra research, and extra mental effort. For a busy student, that means sustainability often loses to convenience — not because they do not care, but because the system around them does not make better choices easy.

So we asked:

What if a calendar didn’t just show your schedule, but actively helped you make better daily decisions — balancing time, energy, health, preferences, productivity, and sustainability goals in one place?

That became MatChalendar: a carbon-aware AI planning agent for student life.

What it does

MatChalendar is a sustainability-aware AI life planner that turns a chaotic student schedule into an executable weekly plan.

It is not just a calendar app, and it is not just a chatbot. MatChalendar acts as a planning orchestrator. It understands a student’s natural language goal, routes the task through specialist planning skills, and generates a structured weekly calendar with explanations, tradeoffs, carbon impact, and realistic next actions.

A typical demo prompt looks like:

“Plan my UCLA week. I want to reduce carbon emissions, but I had an emergency and took an Uber today. I also have class from 10 to 2 and homework tonight.”

MatChalendar detects the user’s fixed constraints, understands the carbon-reduction goal, accounts for the emergency Uber without judging the user, and replans the rest of the week with realistic adjustments.

It can recommend:

lower-carbon dining options that still support nutrition and energy
homework deep-work blocks based on available time
recovery walks instead of unrealistic intense workouts
walking or transit-friendly transportation choices
sleep wind-down blocks to protect recovery
carbon-aware adjustments that compensate for unavoidable high-emission events

The key product insight is that sustainability should not feel like an extra task. MatChalendar embeds it into decisions students already make every day: where to eat, when to study, how to commute, when to rest, and how to balance energy across the week.

Instead of telling students to “be more sustainable,” MatChalendar makes sustainable choices easier to follow by making them practical, contextual, and personalized.

How we built it

We built MatChalendar as a full-stack AI planning system with a web frontend, Python backend, specialist skill architecture, Agentverse integration, ASI:One invocation, GX10-oriented local runtime support, and Figma Make-assisted product design.

The frontend is a one-screen planning interface. Students can type a natural language goal into a chatbox, run the planner, view the generated weekly calendar, and click individual calendar blocks to understand why each decision was made. The explanation drawer shows reasoning, carbon impact, health and energy signals, sustainability tradeoffs, and skills used.

The backend is built around a planner-orchestrator architecture. Instead of relying on one model to directly invent a schedule, MatChalendar decomposes the planning problem into specialist skills:

Calendar Skill
Dining Skill
Study Skill
Health Skill
Energy Skill
Transportation Skill
Sustainability / Carbon Skill
Explanation Skill

Our core design principle is:

Skills propose. Planner decides. Calendar renders.

The planner receives the user’s prompt, detects constraints and goals, calls relevant skills, resolves tradeoffs, and returns a structured weekly calendar plan.

This architecture lets MatChalendar make decisions that are more explainable than a generic chatbot response. Each recommendation is tied to a concrete reason: timing, health, energy, carbon impact, food choice, travel mode, or schedule constraint.

Agentverse and ASI:One integration

For the Agentverse track, we registered MatChalendar as an Agentverse Chat Protocol agent so it can be discovered and invoked through ASI:One.

Agent name: MatChalendar Campus Planner Agent Agent handle: @matchalendar

Agentverse Profile: https://agentverse.ai/agents/details/agent1qgckjr38ks3wflddkzw3rh0ynf64z4uv2ec9axmcm40pwnr9jz7rcs5kmta/profile

ASI:One Shared Chat: https://asi1.ai/invite?channelInviteKey=MK7fcyyuh87kQxz0dtADv7U9apOLYt91VXMCTKtjXr8

The full agent flow is:

ASI:One → @matchalendar Agentverse agent → MatChalendar backend planner → specialist skills → structured calendar response → ASI:One chat answer

This means MatChalendar is not only a standalone web demo. It also works as an external campus-life planning capability that can be invoked through the Agentverse ecosystem.

ASUS Ascent GX10 / local-first runtime

For the ASUS Hardware Challenge, we designed MatChalendar around a local-first planning runtime.

Student life data is highly personal. A student’s schedule, dining habits, health preferences, energy levels, transportation patterns, and sustainability goals reveal sensitive lifestyle information. Because of that, MatChalendar is designed so the planner backend can run on the ASUS Ascent GX10 and serve the planning API over a local or tailnet network.

The GX10-oriented runtime gives MatChalendar a stronger privacy and reliability story: the planner does not need to depend entirely on a cloud-only execution path. The backend can run locally, expose health and runtime status endpoints, and generate planning responses through deterministic fallback when external AI services are unavailable.

This made the system more robust for demo conditions and gave us a practical edge-computing architecture for future local inference, ranking, and personalization.

Figma Make design process

For the Figma Make Challenge, we used Figma Make to prototype the explanation experience quickly.

A major design problem was how to show AI reasoning without overwhelming the user. We explored structured card-based layouts, minimal text-first explanations, and hybrid designs that show only the most important signals: why this block exists, what skills were used, and how it affects carbon, health, energy, and time.

Figma Make helped us move faster from abstract product logic to concrete UI decisions, especially around the calendar explanation drawer and sustainability impact display.

Challenges we ran into

One major challenge was making sustainability recommendations feel supportive instead of preachy.

Many sustainability apps implicitly shame users for high-carbon decisions. We wanted the opposite. If a student takes an Uber because of an emergency, MatChalendar should not say they failed. It should understand the constraint, update the plan, and help them recover toward their weekly goal through future choices.

This led us to design carbon-aware replanning as a balancing system. The planner accepts real life first, then adjusts future meals, routes, study blocks, and recovery time in a realistic way.

Another challenge was making AI planning explainable. A normal chatbot answer is not enough for a calendar product. If the system places a dinner block at 6:30 PM, recommends Bruin Plate, schedules homework at 7:45 PM, or suggests walking instead of taking a ride, the user needs to know why.

To solve this, we built structured plan outputs with calendar blocks, reasons, scores, carbon notes, and skills used. The goal was not just to generate a plan, but to make the plan inspectable.

The Agentverse integration was also technically challenging. We had to connect multiple pieces end to end:

ASI:One → Agentverse agent → public endpoint → MatChalendar backend → planner response → returned chat answer

We debugged agent registration, endpoint routing, ngrok forwarding, /submit compatibility, agent seed consistency, profile visibility, and ASI:One test behavior. Getting the agent to successfully return MatChalendar planning responses through ASI:One was one of the most important milestones of the project.

For the GX10 path, the challenge was making the system credible as a local-first runtime rather than just a cloud demo. We transferred the project onto the GX10, prepared backend startup scripts, added runtime status logic, and structured the planner so it could continue producing useful plans even without relying on external services.

For the Figma Make challenge, the challenge was communicating a complex AI planning process in a simple interface. We needed to show planner reasoning, skill traces, carbon impact, and calendar decisions without making the UI feel like a debug dashboard. Figma Make helped us iterate on this balance quickly.

Accomplishments that we're proud of

We are proud that MatChalendar became much more than a sustainability chatbot.

By the end of the hackathon, we had built a working AI planning system that produces structured calendar blocks, explains its decisions, tracks carbon-aware tradeoffs, and connects multiple planning domains: class schedules, homework, meals, energy, transportation, recovery, and sustainability.

We are especially proud of the carbon-aware replanning flow. The system does not treat sustainability as a moral score. It treats it as an adaptive planning constraint. If life forces a high-carbon choice, MatChalendar helps the user adjust future decisions without guilt.

We are also proud of the Agentverse and ASI:One integration. MatChalendar is registered as an Agentverse Chat Protocol agent with the handle @matchalendar, and ASI:One can invoke it as a campus-life planning capability. This makes MatChalendar part of a larger agent ecosystem instead of just a standalone demo.

We are proud of the GX10-oriented architecture. We designed the system around a local-first backend runtime, privacy-aware planning, runtime status visibility, and deterministic fallback. That gave the product a stronger story for edge AI and private student data.

We are also proud of the product design. The calendar interface, explanation drawer, skill traces, carbon notes, and Figma Make iterations helped turn a complex planning architecture into something users can actually understand.

Most importantly, we are proud that the project connects sustainability with daily life. MatChalendar does not ask users to become perfect. It helps them make better decisions within the life they already have.

What we learned

We learned that the hardest part of building an AI product is not simply calling a model. The hard part is designing a decision system that is useful, trustworthy, and explainable.

We also learned that sustainability works best when it is embedded into existing routines. A student is much more likely to follow a lower-carbon recommendation if it also saves time, fits their schedule, supports their energy, and respects their preferences.

We learned that agent systems are most powerful when they expose a clear specialist capability. MatChalendar does not try to be a general assistant. It is focused on one domain: campus-life planning. That focus made it easier to design the skills, agent behavior, and demo flow.

We learned the importance of fallback design. Hackathon systems need to work under messy conditions: network issues, API failures, endpoint problems, and time pressure. Building deterministic fallback into the planner made the product much more stable.

We also learned that UI matters as much as architecture. If users cannot understand why the AI made a decision, they will not trust it. The explanation drawer became a core part of the product, not just a visual add-on.

Finally, we learned that local-first AI is not only a technical choice. It is a product position. For student planning, privacy and reliability are part of the user experience.

What's next for MatChalendar

The next step is connecting MatChalendar to real campus data sources.

We want to integrate live UCLA dining menus, campus maps, transportation APIs, carbon factor databases, and personal calendars so the planner can make more accurate recommendations in real time.

We also want to improve personalization. Over time, MatChalendar should learn a user’s routines, food preferences, energy patterns, workout habits, study rhythms, and sustainability goals. The goal is to make planning feel less like filling out a form and more like working with a personal life operating system.

On the technical side, we want to expand the skill system so the planner can handle more complex tradeoffs: exam weeks, dietary restrictions, gym routines, commute constraints, weather changes, social events, deadlines, and long-term carbon goals.

For Agentverse, we want MatChalendar to become a reusable campus-life planning agent that other agents and services can invoke when they need schedule-aware, sustainability-aware planning.

For ASUS GX10, we want to move from local backend execution toward deeper local inference, including local ranking, explanation generation, personalization memory, and privacy-preserving planning directly on edge hardware.

In the long term, MatChalendar can expand beyond college campuses into a broader daily decision system for work, travel, wellness, and sustainable living.

Our vision is simple: