Paritok usage dashboard
CityOS Built with Paritok
Paritok Compression in action with CityOS

CityOS: An AI-Powered Operating System for Smarter Cities

Inspiration

Every day, millions of people struggle to find reliable local information. Job opportunities, internships, scholarships, government services, businesses, community events, and emergency updates are often scattered across websites, social media pages, messaging groups, and word of mouth. This fragmentation makes it difficult for people to discover opportunities that could improve their lives.

CityOS was inspired by a simple question:

What if every city had an intelligent AI assistant that could understand natural language, discover local opportunities, and help people take action immediately?

Our goal was to build more than a search engine — we wanted to create an AI-powered operating system that connects citizens with opportunities, services, and resources through one intelligent interface. For the Paritok Token-Efficiency Hackathon, we also wanted to prove that an agentic, multi-turn AI product like this doesn't have to ship bloated context on every request — it can be lean without cutting quality.

What it does

CityOS is an AI-powered city assistant that helps citizens discover opportunities, services, businesses, and community information around them in real-time through a single intelligent interface.

Instead of navigating multiple websites or searching through countless social media posts, users simply ask questions in natural language, such as:

"What opportunities are available this week?"
"Find AI internships near me."
"What community events are happening today?"
"Show me scholarships I can apply for."

CityOS understands the user's intent and returns organized, relevant, and personalized results in seconds.

One of CityOS's most impactful features is its AI Career Assistant. After discovering a job, internship, or scholarship, users can automatically generate a professional CV and a tailored cover letter that match the selected opportunity, chat with an AI coach across multiple turns about their matches and roadmap, and get a step-by-step plan to actually pursue it. This helps applicants create stronger applications in minutes and increases their chances of securing opportunities.

How we used Paritok

This is where the hackathon's actual challenge came in: prove real token savings inside a genuine workflow, not just bolt an API call onto a demo.

We didn't wrap every LLM call in Paritok. Most of CityOS's Groq calls — profile analysis, roadmap generation, CV and cover letter writing — are single-turn JSON generation with no accumulated context, which is a workload Paritok's own documentation describes as one it's less suited for. Compressing those would have padded a number without doing real work.

Instead, we restructured two endpoints specifically to give Paritok genuinely compressible traffic:

POST /recommend — rather than a static prompt, this is agentic: the model is given a search_opportunities tool and decides its own query, we run a real pgvector similarity search against our opportunities knowledge base, and return the results as an actual tool_result message. That result set is exactly the kind of repetitive, high-volume payload Paritok's compression model is built for.
POST /chat — a multi-turn career coaching conversation that genuinely accumulates history across turns. Once a thread passes six turns, everything older than the most recent six is compressed through Paritok before being resent to Groq.

Both call Paritok's hosted GPU compress endpoint directly over HTTP — no local proxy process or CLI to run. Every call fails safe: if Paritok is unreachable, misconfigured, or returns something unexpected, the original uncompressed content is used and the request still succeeds, so compression is an optimization here, never a hard dependency.

We track our own running character-in/character-out totals at GET /paritok/stats for a live demo view, and we're reporting those real, measured numbers rather than the benchmark's headline 74% figure — that number comes from SWE-bench-style coding-agent sessions with much heavier tool-output repetition than a single search call or a short chat thread. A smaller, honest number tied to real usage felt more useful to show than an inflated one that wouldn't match the Paritok dashboard.

How we built it

CityOS combines modern web technologies, cloud infrastructure, and artificial intelligence to deliver a fast, intuitive, and scalable user experience.

Frontend

Nuxt.js / Vue.js
Tailwind CSS
Supabase Authentication

Backend

FastAPI
REST APIs
PostgreSQL (via Supabase)
pgvector for semantic search
NumPy

AI layer

Groq API for high-speed LLM inference
Paritok's hosted GPU compress endpoint for context compression on agentic tool results and multi-turn chat history
Natural language understanding, semantic search, and context-aware recommendations
AI-powered CV & cover letter generation

Infrastructure

For this submission, CityOS runs locally end to end — FastAPI backend, Nuxt frontend, and a Supabase project for Postgres, pgvector, and Auth. Full setup instructions are in the repo README. (Heroku/Vercel hosting is on our near-term roadmap, not part of this submission.)

Data

CityOS aggregates and organizes city-related information into a searchable knowledge base, enabling users to quickly discover opportunities, businesses, government services, and community resources through intelligent, embedding-based search.

Challenges we faced

One of the biggest challenges was designing an AI experience that feels natural while still providing accurate and relevant information.

Another challenge involved organizing multiple categories of city information — jobs, internships, scholarships, businesses, government services, and community events — into a unified system that users could search effortlessly.

Building the AI-powered career assistant also required carefully designing prompts capable of generating professional CVs and personalized cover letters suitable for different types of opportunities, and a chat experience that stays coherent across many turns.

For the Paritok integration specifically, the challenge wasn't wiring up an API call — it was figuring out honestly where compression actually helps. Most of our LLM calls don't have the kind of repetitive, accumulating context Paritok is designed for, so we had to identify and restructure the two endpoints that genuinely do, rather than compressing everything just to report a bigger number.

What we learned

Building CityOS reinforced an important lesson:

AI creates the greatest impact when it helps people solve real-world problems — and it's most efficient when compression is applied where the context actually justifies it, not everywhere by default.

Throughout development, we gained valuable experience in:

Designing AI-first user experiences
Integrating LLMs into production-style applications, including agentic tool use
Implementing semantic search for intelligent information retrieval
Structuring city information for efficient discovery
Building scalable web applications
Engineering AI-generated career documents
Measuring and reporting real token/character savings instead of assuming compression helps everywhere
Creating intuitive interfaces for users of all technical backgrounds

Most importantly, we learned that successful AI products aren't defined solely by powerful models or by adding every optimization available — they succeed by making technology practical, accessible, and genuinely useful, and by applying tools like Paritok where they honestly earn their place.

What's next

CityOS is designed to become a comprehensive AI operating system for smart cities.

Our roadmap includes:

Hosted deployment (Heroku/Vercel) for a live public demo
Personalized AI recommendations
Real-time public service updates
Expanded opportunity discovery
AI-powered interview preparation
Multilingual support
Community-driven local knowledge
Integration with additional public and private data sources
Smarter, location-aware recommendations
Extending Paritok compression to additional accumulating-context workflows as they're added

Our long-term vision is simple:

Make every city easier to navigate, every opportunity easier to discover, and every citizen more empowered through artificial intelligence — built lean from the start.

By combining intelligent search, opportunity discovery, AI-powered career assistance, and efficient use of Paritok, CityOS helps people not only find opportunities but also prepare for them and confidently take the next step toward success.