
How I Built CampusOps with Strands Agents: From One Sentence to a Real Campus Event
I watched clubs waste 2-3 hours per event on rooms and forms, so I built CampusOps — a Strands agent that turns one sentence into real room locks, permission PDFs, Forms/Sheets and announcements, and only asks humans for approval.
How I Built CampusOps with Strands Agents: From One Sentence to a Real Campus Event
I didn't want another chatbot that explains how to run an event. I wanted an agent that actually runs it for me and only taps me when a human decision is needed.
That's what I built for the
Everyday Agents track.The Problem I Live With at College
At Govt. Model Engineering College, every club — FOSS MEC, MACS, IEEE — does the same thing every week:
Find a room with enough capacity → write a permission letter to the Principal → create a Google Form → link a Sheet → send an announcement → track registrations → send reminders.
It's 3–5 hours of fragmented work across Gmail, Forms, Sheets, and a paper ledger.
An LLM that just says "you should find a room" is useless.
I wanted an agent that does the work.
What I Built: CampusOps
I give it one sentence and it does the ops:
"FOSS MEC wants to conduct a GIT workshop for 50 students on 2026-09-10 15:30-16:30 with speaker John Doe"
From that, CampusOps:
- Extracts
org,title,date→YYYY-MM-DD,start_time/end_time,speaker,purpose,need_onfoot, and custom form fields.
- Finds a room via live Google Sheets (
RoomInventory!A2:B+Bookings!A2:F) with real time-overlap checks —max(s1,s2) < min(e1,e2)— against both the Sheet and a localroom_bookingsSQLite ledger.
- Atomically locks it with
book_room_slot()— re-checking the DB + Sheet for conflicts before writing[Room, Date, Start, End, EventID, Org]toBookings!A:Fand inserting intoroom_bookings.
- Generates institution-aware permission + on-foot publicity letters using per-org
OrgSettings(institution_name,chairperson,staff_in_charge) and renders them as PDFs withreportlab— editable before anything is sent.
- Waits for me to hit Send to Principal — it never auto-sends. After my confirmation, it emails the Principal with the PDFs attached.
- After the Principal (admin role) hits Approve, it creates a real Google Form with dynamic
text/paragraph/multiple_choice/checkbox/file_uploadfields, creates a linkedResponsesSheet with bold headers, creates a Drive folder for file uploads if needed, and sends the announcement.
- Polls
Forms.list(responses)→Sheetsevery 60 seconds viasync_responses_to_sheet()so registrations appear even without manually linking the Form to a Sheet.
The principle I coded around:
Action over explanation. Human control over authorization.
The lifecycle is:
DRAFT → PENDING_APPROVAL → LIVE → CLOSED It's stored in SQLite and designed to move to AgentCore Memory.
How I Built It with Strands Agents
I'm using:
-
strands-agents==1.53.0
-
strands-agents-tools==0.8.6
- Gemini 3.5 Flash Lite via
google-genai
-
FastAPI==0.141.1
I keep a single flat agent on purpose. One
Agent with a tight system prompt beats a flaky multi-agent demo for an MVP:# backend/app/agent.py:81
agent = Agent( model=GeminiModel( model_id="gemini-3.5-flash-lite", params={"temperature": 0.4} ), system_prompt=SYSTEM_PROMPT, # Today is YYYY-MM-DD (Weekday) + hard rules tools=[ check_room_availability, book_room_slot, generate_permission_letter, generate_onfoot_letter, create_registration_form, send_announcement, get_registration_count, upsert_event, ])
The system prompt I wrote does two important things:
- Injects
Today is {today} ({weekday})so"next Saturday"always resolves correctly.
- Forbids hallucinations: if the source is
mock_fallback, disclose it, and never assume approval.
The Trick That Saved Me: A Deterministic Fast-Path
The biggest optimization I made is a deterministic fast-path in:
backend/app/main.py:140 → _create_event_deterministically() If the frontend already provides
date + start_time + end_time , I skip Gemini entirely.I call:
check_room_availability() ↓book_room_slot() ↓generate_permission_letter() ↓save_event()
The whole path runs in <500ms.
That cut roughly 90% of LLM calls and made local testing almost instant.
The agent is still there for messy natural-language cases, but I don't pay for an LLM call when I don't need one.
Narrow, Pydantic-Validated Tools
My tools are intentionally narrow and Pydantic-validated.
For example,
check_room_availability in:backend/app/tools/room.py:178 does a strict
YYYY-MM-DD check, parses both 15:30 and 3:30 PM into minutes, reads RoomInventory and Bookings , and even supports auto-migration from the old Rooms! single-sheet format.It also checks the SQLite ledger using
check_room_conflict() .A successful response looks like:
{ "room": "SDPK", "capacity": 60, "source": "live_sheet"}
Or it returns a
409 with:{ "conflicts": [], "alternatives": []}
That made the agent much more reliable.
Going Real with Google APIs
For Google, I went real:
- Forms API v1
- Sheets API v4
- Drive API v3
- Gmail API v1
with scopes including:
drive.fileforms.bodyspreadsheetsgmail.composegmail.send
In
backend/app/google/auth.py:34 , I cache credentials per organization:token_foss_mec.jsontoken_macs.json...
with a 60-second TTL and a 3-second timeout.
I also added:
CENTRAL_DRIVE=true
in
backend/app/config.py:51 .By default, the admin owns one Drive and shares per-club folders with writer access to the club's Gmail, so clubs need zero OAuth setup.
If a club wants isolated credentials, they can run:
python scripts/auth_google.py --org "FOSS MEC"
and then use:
GET /auth/google/url
Creating the Registration Form
In
backend/app/tools/forms.py:33 , I create the Form using forms.create , update its description with updateFormInfo , and then use batchUpdate for each dynamic question.Supported field types include:
-
text
-
paragraph
-
multiple_choice
-
checkbox
-
file_upload
For
file_upload , I create a Drive folder using _create_upload_folder() and provide the folder link.I also create the linked Sheet myself so I can return both:
form_linksheet_link
immediately.
Announcements
Announcements live in:
backend/app/tools/announcement.py:7 I reuse the pre-approved
announcement_draft from the event, inject the real registration_link , and prefer Brevo ( sib-api-v3-sdk ) before falling back to Gmail.That means the announcement can still go out even if Gmail isn't verified.
Registration Tracking
Registration logic lives in:
backend/app/tools/registrations.py:62 I try Sheets first:
Responses!A2:Z
and then fall back to:
forms.responses.list
with pagination.
I also automatically sync responses using:
sync_responses_to_sheet()
which clears:
Responses!A2:Z
and writes:
[responseId, createTime, respondentEmail, ...answers]
Mock mode still works, so judges can test the entire workflow offline.
Architecture
The current architecture is:
User │ ▼Strands Agent │ ├──► Room Tools ├──► Forms Tools └──► Gmail Tools │ ▼ Google Sheets / Forms / Gmail └──► SQLite Event State │ ▼ Human Approval Boundary
I'm not deployed to Bedrock AgentCore yet — I run locally — but I built the state layer with that migration in mind.
My SQLite state includes:
-
Event
-
OrgSettings
-
users
-
room_bookings
It's running in WAL mode in
backend/app/state.py:51 .I also have
get_latest_event() and a daily _reset_loop() that prunes past bookings.The intended mapping is:
Current SQLite State │ ├──► AgentCore Runtime │ └──► AgentCore Memory
So the current architecture has a fairly direct path to an AgentCore deployment.
Challenges I Ran Into
Gemini Hallucinating Rooms and Approvals
Gemini would sometimes hallucinate rooms or pretend an approval had happened.
I fixed that with:
- Strict
field_validators for dates/times
- A global
_agent_invocation_lockinbackend/app/main.py:33
- Explicit source disclosure such as
mock_ledgervslive_sheet_bookings
- Hard rules that prevent the agent from assuming approval
Time Was Harder Than Date
Time overlap was surprisingly easy to get wrong.
For example:
Existing: 16:00–17:00New: 15:30–16:30
These overlap.
The correct check is:
max(s1, s2) < min(e1, e2)
I had to apply this consistently in both
_read_inventory_and_bookings() and check_room_conflict() .Otherwise, clubs could double-book rooms such as SDPK.
OAuth and AWS Credits
OAuth brought its own headaches.
forms.body requires re-consent, and rate limits are real.My AWS account was also suspended after the free tier, so I couldn't use the $50 credits.
I stopped chasing the credits and made:
MOCK_MODE=true
the default for testing.
Judges can therefore test 100% locally, and per the rules, AgentCore deployment is useful but not required.
What I Learned
The biggest lesson for me:
Prompting is 20%. Tool design is 80%.
A good tool does one thing and validates it.
The LLM just sequences those tools.
Useful Autonomy Is Invisible
My agent builds the letters, then waits.
It says:
Room reserved: SDPK (60) for 2026-09-10 15:30-16:30. Here is the draft for the Principal — edit or say "make more formal".
That's the right kind of interruption.
The agent handles the boring work, but authorization stays with the human.
What's Next for CampusOps
Short Term
- Deploy to Bedrock AgentCore
- Add Google Calendar integration
- Add Slack integration
Long Term
I want any campus club to turn intent into operation in one chat.
I built CampusOps because I was tired of the boring work.
You describe it — CampusOps does the ops.
Links
- Video: https://youtu.be/LRXyYXjvQ48
#AgentsforHumans #AgentsofFootball
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article