PulseAI

Inspiration

Every club president at Fordham — and across 5,000 universities in the US — does the same thing before every meeting. Manually create an event, copy details into an email, write a reminder, follow up, collect RSVPs one by one. Twenty to thirty minutes of admin work, every single time. Multiply that by millions of student organizations and nonprofits that can't afford enterprise software, and you have billions of hours of human time wasted on coordination instead of actual impact. We built the solution.

What it does

PulseAI is a true autonomous AI agent for organizational management. A club president types one natural language instruction — the agent does everything else. From a single sentence it autonomously extracts event details, creates the event, checks for scheduling conflicts against the campus calendar, notifies all members via real-time in-app notifications and email, schedules reminders that fire automatically with zero human trigger, collects RSVPs through a Partiful-style event page, and tracks the event budget. Nobody touches anything after the first message. The agent plans, executes, observes results, and acts across time on its own. That is what makes PulseAI a real agent — not a wrapper.

How we built it

Agent layer: Claude claude-sonnet-4-6 tool-calling API running a genuine multi-step agent loop. Claude selects tools, calls them in sequence, reads results back from the database, makes decisions, and continues until the task is fully complete. Patterns referenced directly from Anthropic's claude-cookbooks and courses repositories. Real-time layer: Flask-SocketIO with eventlet broadcasts every agent action live to the browser as it happens — tool calls, notifications, conflict checks, reminder scheduling, and RSVP updates stream in real time via WebSockets. Autonomous scheduling: Flask-APScheduler v3 registers reminder jobs that fire automatically at the exact scheduled time — no human trigger, no cron job, no polling. Backend: Python, Flask, SQLite for zero-config persistence, SendGrid for email delivery. Frontend: Vanilla JavaScript with Apple-style scroll reveal animations, single column layout, warm dark gold design system. Deployed: Render.com — live public URL accessible from any device on any network.

Challenges we ran into

The hardest technical challenge was making the agent loop genuinely autonomous rather than just sequential. Claude needed to call tools in the right order, handle tool results correctly, and continue looping without human re-prompting — all while streaming real-time events to the browser via WebSocket without blocking the agent thread. APScheduler v3 required careful threading integration with eventlet's async model to fire reminders autonomously without crashing the Flask process. The reminder firing live during the demo — with zero human trigger — was the moment that proved the architecture actually worked. Separating the agent's execution context from the WebSocket broadcast context required injecting dependencies at runtime rather than importing them statically — a pattern we confirmed directly from Anthropic's agent SDK examples.

Accomplishments that we're proud of

Building a genuine autonomous agent — not a chatbot wrapper — in under 24 hours. The distinction matters architecturally: Claude never just generates text during the workflow. It calls tools, reads database results, makes decisions, and continues until every step completes. The text summary only appears at the end. Watching the reminder fire automatically on screen during testing for the first time — with no button clicked, no trigger sent — was the moment we knew we had built something real. The Apple-style scroll reveal UI, the Partiful-style event page, the live budget tracking, and the member management system were all built and deployed within the hackathon window.

What we learned

The difference between a wrapper and an agent is architectural, not cosmetic. Most teams call an AI API and display the response. A real agent loop — tool calling, result reading, decision making, continuation — requires fundamentally different engineering. Real-time autonomous systems require careful dependency injection. SocketIO, APScheduler, and the agent loop all need to share state without circular imports — the pattern of injecting dependencies at runtime rather than import time was the key insight that made everything work together. We also learned that the most compelling demos are the ones where the technology speaks for itself. The moment the reminder fires on screen without anyone clicking anything — that silence is more convincing than any explanation.

What's next for PulseAI

Short term: Multi-club platform with club registration, member join flows, and scoped notifications — so different clubs host their own events and only their members receive notifications. Medium term: Calendar integrations — Google Calendar, Outlook — so the agent can detect real scheduling conflicts across actual employee calendars, not just internal events. Enterprise deployment: The same agent framework adapted for corporate team coordination. A manager types one sentence. The agent schedules the meeting, notifies the right people, detects conflicts across department calendars, collects confirmations, and sends follow-ups. JPMorgan has hundreds of thousands of employees doing this manually every day. Model agnostic: The tool-calling loop, autonomous scheduler, and real-time notification system are the IP — not the AI model. PulseAI runs on Claude today. It runs on Gemini tomorrow. The framework is the product.

Built With

• anthropic
• apscheduler
• claude-api-(claude-sonnet-4-6)
• css
• eventlet
• flask
• flask-socketio
• html
• javascript
• python
• render
• sendgrid
• sqlite
• websockets