Building a University Admissions Agent: Application Guidance and Status Tracking

Why Universities Need an Admissions Agent

University admissions offices handle thousands of inquiries each cycle. Prospective students ask about requirements, deadlines, missing documents, and application status — often the same questions repeated across emails, phone calls, and walk-ins. An AI admissions agent can handle these queries instantly, freeing staff to focus on holistic review and relationship building.

This tutorial builds a complete admissions agent that manages application requirements, tracks deadlines, maintains document checklists, and provides status updates.

Defining the Application Data Model

Every admissions system starts with structured data about programs and their requirements.

from dataclasses import dataclass, field
from datetime import date, datetime
from enum import Enum
from typing import Optional


class ApplicationStatus(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    SUBMITTED = "submitted"
    UNDER_REVIEW = "under_review"
    DECISION_MADE = "decision_made"


class DocumentStatus(Enum):
    MISSING = "missing"
    UPLOADED = "uploaded"
    VERIFIED = "verified"
    REJECTED = "rejected"


@dataclass
class ProgramRequirement:
    program_name: str
    degree_level: str
    department: str
    gpa_minimum: float
    test_scores_required: list[str]
    required_documents: list[str]
    application_deadline: date
    early_deadline: Optional[date] = None
    supplemental_essays: int = 0


@dataclass
class ApplicantDocument:
    document_type: str
    status: DocumentStatus
    uploaded_at: Optional[datetime] = None
    reviewer_notes: Optional[str] = None


@dataclass
class Application:
    applicant_id: str
    applicant_name: str
    email: str
    program: str
    status: ApplicationStatus = ApplicationStatus.NOT_STARTED
    documents: list[ApplicantDocument] = field(default_factory=list)
    submitted_at: Optional[datetime] = None
    decision: Optional[str] = None

This model captures the full lifecycle from initial interest through final decision.

Building the Admissions Agent Core

The agent needs tools for checking requirements, managing documents, and tracking status.

from agents import Agent, function_tool, Runner
import json


# Simulated database
PROGRAMS_DB: dict[str, ProgramRequirement] = {}
APPLICATIONS_DB: dict[str, Application] = {}


def seed_programs():
    PROGRAMS_DB["cs-ms"] = ProgramRequirement(
        program_name="Master of Science in Computer Science",
        degree_level="Masters",
        department="Computer Science",
        gpa_minimum=3.2,
        test_scores_required=["GRE General"],
        required_documents=[
            "Transcripts", "Statement of Purpose",
            "Three Letters of Recommendation", "Resume",
            "GRE Score Report"
        ],
        application_deadline=date(2026, 12, 15),
        early_deadline=date(2026, 10, 1),
        supplemental_essays=1,
    )
    PROGRAMS_DB["mba"] = ProgramRequirement(
        program_name="Master of Business Administration",
        degree_level="Masters",
        department="Business School",
        gpa_minimum=3.0,
        test_scores_required=["GMAT or GRE"],
        required_documents=[
            "Transcripts", "Resume", "Two Essays",
            "Two Letters of Recommendation", "GMAT/GRE Score"
        ],
        application_deadline=date(2026, 1, 15),
        early_deadline=date(2025, 10, 15),
        supplemental_essays=2,
    )

seed_programs()


@function_tool
def get_program_requirements(program_code: str) -> str:
    """Retrieve admission requirements for a specific program."""
    program = PROGRAMS_DB.get(program_code)
    if not program:
        available = ", ".join(PROGRAMS_DB.keys())
        return f"Program not found. Available programs: {available}"
    days_left = (program.application_deadline - date.today()).days
    return json.dumps({
        "program": program.program_name,
        "department": program.department,
        "gpa_minimum": program.gpa_minimum,
        "test_scores": program.test_scores_required,
        "required_documents": program.required_documents,
        "deadline": program.application_deadline.isoformat(),
        "days_until_deadline": days_left,
        "early_deadline": (
            program.early_deadline.isoformat()
            if program.early_deadline else None
        ),
        "supplemental_essays": program.supplemental_essays,
    })


@function_tool
def check_document_status(applicant_id: str) -> str:
    """Check which documents have been submitted and which are missing."""
    app = APPLICATIONS_DB.get(applicant_id)
    if not app:
        return "No application found for this applicant ID."
    program = PROGRAMS_DB.get(app.program)
    if not program:
        return "Program not found for this application."

    submitted = {d.document_type for d in app.documents
                 if d.status != DocumentStatus.MISSING}
    required = set(program.required_documents)
    missing = required - submitted

    return json.dumps({
        "applicant": app.applicant_name,
        "program": app.program,
        "documents_submitted": list(submitted),
        "documents_missing": list(missing),
        "completion_percentage": round(
            len(submitted) / len(required) * 100
        ) if required else 100,
    })


@function_tool
def get_application_status(applicant_id: str) -> str:
    """Get the current status of a student application."""
    app = APPLICATIONS_DB.get(applicant_id)
    if not app:
        return "No application found. Please start a new application."
    return json.dumps({
        "applicant": app.applicant_name,
        "program": app.program,
        "status": app.status.value,
        "submitted_at": (
            app.submitted_at.isoformat() if app.submitted_at else None
        ),
        "decision": app.decision,
    })

Wiring Up the Agent

admissions_agent = Agent(
    name="University Admissions Assistant",
    instructions="""You are a university admissions assistant.
    Help prospective students understand program requirements,
    track their application status, check document completeness,
    and meet deadlines. Be encouraging but accurate. Always
    provide specific dates and actionable next steps. If a
    deadline is approaching within 30 days, flag it urgently.""",
    tools=[
        get_program_requirements,
        check_document_status,
        get_application_status,
    ],
)

result = Runner.run_sync(
    admissions_agent,
    "What are the requirements for the CS masters program?"
)
print(result.final_output)

Deadline Alert System

A production admissions agent should proactively warn about approaching deadlines.

from datetime import timedelta


def generate_deadline_alerts(days_warning: int = 30) -> list[dict]:
    alerts = []
    today = date.today()
    for app_id, app in APPLICATIONS_DB.items():
        program = PROGRAMS_DB.get(app.program)
        if not program or app.status == ApplicationStatus.SUBMITTED:
            continue
        days_left = (program.application_deadline - today).days
        if 0 < days_left <= days_warning:
            alerts.append({
                "applicant_id": app_id,
                "applicant_name": app.applicant_name,
                "program": program.program_name,
                "deadline": program.application_deadline.isoformat(),
                "days_remaining": days_left,
                "urgency": "critical" if days_left <= 7 else "warning",
            })
    return sorted(alerts, key=lambda a: a["days_remaining"])

FAQ

How does the agent handle programs with rolling admissions?

For rolling admissions, set the deadline to the final date the program accepts applications and add a priority deadline field. The agent can explain that applications are reviewed as received and earlier submissions improve chances of acceptance and financial aid availability.

Can this agent integrate with existing Student Information Systems?

Yes. Replace the in-memory dictionaries with API calls to your SIS (Banner, PeopleSoft, Slate, etc.). The tool functions become thin wrappers around REST or SOAP endpoints. The agent logic and conversation flow remain identical regardless of the data source.

How should the agent handle sensitive admissions decisions?

The agent should never reveal decision rationale or compare applicants. It can report status (under review, decision made) and direct students to their decision letter. Configure the agent instructions to explicitly refuse requests for admission predictions or committee deliberation details.

---

#AIAgents #EdTech #UniversityAdmissions #Python #Education #AgenticAI #LearnAI #AIEngineering