CampusSync

Agentic University Workforce Coordinator: One student. Multiple campus jobs. One intelligent schedule.

Comment

Inspiration

Campus student employment looks simple until one student works in more than one place.

A student may work as a research assistant for one department and also work a shift-based campus job such as dining, a library, or another university organization. Each department manages its own schedule independently, but the student still has only one calendar, one set of available hours, and one overall work-hour limit.

This creates a real coordination problem.

A student may be available to one department on paper but already scheduled somewhere else. Managers can accidentally create overlapping shifts, students have to manually message supervisors to resolve conflicts, and shift swaps often involve multiple emails and approvals.

For international students, this becomes even more important because their university employment may also be subject to configured weekly work-hour limits.

We wanted to answer one question:

Can multiple university organizations coordinate around the same student without exposing their schedules to each other?

That became CampusSync.

One student. Multiple campus jobs. One intelligent schedule.

What it does

CampusSync is a privacy-preserving, multi-agent workforce coordination platform for university student employment.

There are two main users:

Students

Students can:

  • create their employment profile
  • define weekly availability
  • track their configured weekly work-hour limit
  • view all of their own campus jobs in one calendar
  • view upcoming shifts
  • request shift changes
  • request shift swaps
  • receive notifications
  • synchronize relevant events with Google Calendar

A student sees their complete personal schedule because all of that information belongs to them.

University organizations

Organizations can:

  • define staffing requirements
  • create weekly shifts
  • enable or disable individual shifts
  • generate schedules automatically
  • view their own organization calendar
  • identify open or understaffed shifts
  • publish schedules
  • review shift-change requests
  • approve valid swaps
  • use AI-assisted scheduling and explanations

The important part is what organizations cannot see.

If a student also works for another university organization, CampusSync does not reveal that organization's schedule.

For example, if a student is already occupied from 2–4 PM somewhere else, another department simply receives:

Blocked — Student unavailable for this time.

It does not receive:

Student is working for Department X from 2–4 PM.

CampusSync therefore coordinates across organizations while maintaining separation between them.

Multi-Agent System

CampusSync is not built around one large chatbot.

We designed the scheduling workflow as a team of specialized agents.

Coordinator Agent

Orchestrates the complete scheduling workflow and delegates work to the appropriate agents.

Availability Agent

Checks whether a student is available for the entire requested shift.

Conflict Agent

Detects overlapping assignments, including conflicts with hidden assignments from other university organizations.

Policy Agent

Validates configured work-hour rules before an assignment is approved.

Department Requirement Agent

Understands how many students are required for each enabled shift.

Scheduling Agent

Generates valid student-to-shift assignments after all hard constraints have been checked.

Optimization Agent

Chooses among valid scheduling alternatives using factors such as staffing coverage, desired hours, fairness, and workload balance.

Shift Swap Agent

Finds reciprocal shift exchanges between students.

For example:

Student A wants:

2–4 PM → 6–8 PM

Student B wants:

6–8 PM → 2–4 PM

The agent can detect the reciprocal match and validate both students before presenting or automatically processing the swap.

Replacement Agent

Finds qualified students when someone needs coverage and no direct reciprocal swap exists.

Notification Agent

Notifies students and organizations when schedules are published, swaps are approved, or new shifts become available.

Together, these agents turn scheduling into a coordinated workflow instead of a collection of isolated CRUD operations.

How we built it

CampusSync was built as a full-stack application centered around JacLang.

We used Jac because the problem naturally maps to connected entities:

  • Students
  • Organizations
  • Employment relationships
  • Availability
  • Shifts
  • Schedules
  • Work policies
  • Swap requests
  • Notifications

Instead of treating these as disconnected records, we model the workforce as a graph and use Jac walkers to traverse and act on that graph.

The multi-agent workflows are implemented through Jac-based walkers and orchestration logic.

We intentionally kept hard scheduling rules deterministic.

For example:

  • time overlaps
  • weekly-hour calculations
  • shift eligibility
  • enabled/disabled status
  • authorization
  • conflict detection

are validated through application logic rather than asking an LLM to make factual compliance decisions.

AI is used where semantic reasoning adds value, including intelligent scheduling assistance, natural-language interaction, decision explanations, and ranking valid alternatives.

We also integrated Google Calendar so scheduling can connect to the calendar students already use.

Gemini powers AI-assisted features in the backend while deterministic scheduling logic remains authoritative.

The final application is designed to run through JacHammer, allowing the Jac-based full-stack project to be deployed and demonstrated as a working application.

Privacy by design

One of the hardest and most important parts of CampusSync was cross-organization privacy.

The backend may need to know that a student is busy, but the requesting organization does not need to know why they are busy.

We therefore designed our responses around minimum necessary information.

An organization may receive:

  • Confirmed
  • Waiting
  • Blocked
  • Student unavailable
  • Weekly limit exceeded

but never receives another organization's private schedule through that validation process.

This is enforced at the application layer rather than simply hiding information in the frontend.

Scheduling and shift swaps

We wanted CampusSync to reduce the amount of administrative work required from both students and managers.

Organizations can generate a weekly schedule based on:

  • student availability
  • staffing requirements
  • existing assignments
  • configured work-hour limits
  • role requirements
  • scheduling conflicts
  • requested student hours

The generated schedule remains a draft until the organization publishes it.

For changes after publication, students can request a swap in only a few interactions.

CampusSync then checks the request automatically.

A manager can see something like:

  • ✓ Availability confirmed
  • ✓ Work-hour policy confirmed
  • ✓ Department coverage maintained
  • ✓ Role requirement confirmed

and approve the swap quickly.

User experience

We wanted an AI-powered system that still felt like a scheduling product rather than a chatbot.

The interface uses a minimal, light design with:

  • Geist typography
  • compact 4px corner radius
  • generous whitespace
  • simple calendar views
  • responsive layouts
  • clear state indicators
  • no unnecessary visual noise

Every system decision is shown first in one sentence.

For example:

Blocked — This assignment would exceed the student's weekly work-hour limit.

Additional details stay behind a “Why?” control.

This keeps the interface understandable while still making the system transparent.

The application is fully responsive so both students and organization managers can use the scheduling workflows from desktop, tablet, or mobile.

Challenges we faced

Migrating a complete product to JacLang

We first built and validated the complete experience, including UI, scheduling workflows, Google Calendar, Gemini integration, and multiple user roles.

One of our biggest technical challenges was then ensuring that the same product behavior could be represented through a Jac-native architecture without changing the experience users had already tested.

Privacy across organizations

The scheduling engine needs enough information to detect a conflict while revealing as little information as possible to the requesting organization.

Designing that separation affected our data model, agent responses, authorization, and APIs.

Multi-agent coordination

Creating many agents is easy.

Making every agent have a clear responsibility and ensuring deterministic rules remain authoritative was much harder.

We had to separate:

reasoning problems

from:

constraint-validation problems.

Calendar synchronization

External calendar integration introduces synchronization, authentication, event updates, and consistency challenges.

We had to make sure calendar functionality complemented CampusSync's internal schedule rather than becoming another source of conflicts.

Maintaining a simple UX

A scheduling system can quickly become complicated.

We worked hard to keep the student shift-change workflow short and the organization approval workflow even shorter.

Accomplishments that we're proud of

We are especially proud that CampusSync is not just a concept or static prototype.

We built and tested the complete application using seven different accounts across Student and Organization roles.

We successfully demonstrated:

  • multi-organization student employment
  • privacy-preserving conflict detection
  • weekly work-hour validation
  • automatic scheduling
  • calendar-based scheduling views
  • enabled and disabled shifts
  • shift-change requests
  • reciprocal shift swaps
  • organization approvals
  • Google Calendar integration
  • Gemini-powered AI features
  • responsive Student and Organization experiences
  • multi-agent scheduling workflows

Most importantly, the product addresses a problem that can occur in a real university environment.

What we learned

Building CampusSync taught us that agentic AI is most useful when agents have clear responsibilities and operate around reliable software rules.

Not every problem needs an LLM.

An LLM should not decide whether two times overlap or whether 22 is greater than a 20-hour limit.

Instead, AI becomes much more useful when combined with deterministic systems:

AI understands and coordinates.
Software validates and enforces.

We also learned how naturally a university workforce system can be represented as a graph, where students, organizations, shifts, policies, and requests are connected rather than isolated.

That made JacLang particularly interesting for this project.

What's next

CampusSync currently focuses on student employment scheduling, but the architecture can grow much further.

Future improvements could include:

  • university SSO integration
  • class-schedule integration
  • advanced workforce optimization
  • smarter open-shift recommendations
  • university-level administrative controls
  • audit logs and policy reporting
  • additional calendar providers
  • role and skill matching
  • department analytics
  • configurable semester/break employment policies
  • support for other universities

Our larger vision is for CampusSync to become an intelligent coordination layer between students and the many organizations they work with across a university.

Departments can stay independent. Students get one coherent schedule. CampusSync coordinates the space between them.

Built With

Share this project:

Updates

Submission history