AWS Builder Center
 How I Built CampusOps with Strands Agents: From One Sentence to a Real Campus Event

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:
  1. Extracts  org ,  title ,  date  →  YYYY-MM-DD ,  start_time / end_time ,  speaker ,  purpose ,  need_onfoot , and custom form fields.
  1. 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 local  room_bookings  SQLite ledger.
  1. Atomically locks it with  book_room_slot()  — re-checking the DB + Sheet for conflicts before writing  [Room, Date, Start, End, EventID, Org]  to  Bookings!A:F  and inserting into  room_bookings .
  1. Generates institution-aware permission + on-foot publicity letters using per-org  OrgSettings  ( institution_name ,  chairperson ,  staff_in_charge ) and renders them as PDFs with  reportlab  — editable before anything is sent.
  1. Waits for me to hit Send to Principal — it never auto-sends. After my confirmation, it emails the Principal with the PDFs attached.
  1. After the Principal (admin role) hits Approve, it creates a real Google Form with dynamic  text / paragraph / multiple_choice / checkbox / file_upload  fields, creates a linked  Responses  Sheet with bold headers, creates a Drive folder for file uploads if needed, and sends the announcement.
  1. Polls  Forms.list(responses)  →  Sheets  every 60 seconds via  sync_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:
  1. Injects  Today is {today} ({weekday})  so  "next Saturday"  always resolves correctly.
  1. 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.file
forms.body
spreadsheets
gmail.compose
gmail.send

In  backend/app/google/auth.py:34 , I cache credentials per organization:
token_foss_mec.json
token_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_link
sheet_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_validator s for dates/times
  • A global  _agent_invocation_lock  in  backend/app/main.py:33 
  • Explicit source disclosure such as  mock_ledger  vs  live_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:00
New: 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

#AgentsforHumans #AgentsofFootball
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article