Shorty

Shorty turns long videos into reels and generates brainrot content using editable, agent-controlled flowcharts, so users get viral outputs with real control, not black-box AI.

Comment

Project Story

About the project

Canada has a real content gap. Canadians consume enormous amounts of online video and social media, but creators still face structural barriers to producing consistently at scale. Statistics Canada reported that by 2022, nearly 72% of Canadians consumed user-generated video, and regular social media use was already widespread before that. At the same time, a federal survey of Canadian artists and content creators found that only about 41% of respondents worked full-time in their creative occupation, and Canada’s digital industries strategy notes that the country invests less in digital technologies than the OECD average. In other words, demand for content is high, but the production pipeline is still too hard, too manual, and too fragile. (Statistics Canada)

That is the problem we wanted to solve with Shorty.

Shorty is an agentic content creation app with two features:

  1. Long videos to reels
  2. Brainrot generation

The key idea is that both features are powered by editable flowcharts controlled by an agent, not by a black-box one-shot prompt. Instead of asking AI for a result and hoping for the best, users can see the workflow, modify it, and let the agent translate natural-language instructions into structured graph actions.

For Feature 1, Shorty takes a long-form video and turns it into short-form reels. The system can analyze transcript and workflow context, identify promising moments, modify pacing or hook logic, score multiple candidates, and push the best option through the existing execution pipeline.

For Feature 2, Shorty generates chaotic “brainrot” style content through a composable flowchart. Users can tell the agent things like “add subway surfers after the hook” or “use a female voice,” and the system updates the graph, validates the changes, and runs the output through the same underlying pipeline.

What inspired us

We were inspired by a simple contradiction: Canada has strong creative talent and a meaningful screen-sector economy, but content creation is still too slow for modern internet distribution. Canada’s screen-based production sector contributes billions to GDP, yet a lot of online-native creation still depends on fragmented tools, repetitive manual editing, and weak automation. (CMPA | Home of Canada's media producers)

We wanted to build something that makes Canadian content production faster, more systematic, and more scalable, especially for creators, students, startups, and small teams that do not have studio-style resources.

How we built it

We built Shorty as a non-invasive agent layer on top of existing feature workflows, rather than rebuilding the product around an agent from scratch.

The core idea was simple: let the agent reason about each workflow as a graph, make safe edits to that graph, and then hand control back to the normal product pipeline. This gave us agentic behavior without breaking the manual UX that already worked.

Core architecture

  • Workflow adapter layer that converts each feature into a shared graph representation the agent can understand
  • Retrieval + memory layer backed by Supabase, so the agent can pull relevant prior context instead of starting cold every time
  • Planner/compiler layer using Gemini to turn natural-language intent into structured graph mutations
  • Validation + sanitization layer to prevent unsafe, invalid, or out-of-scope mutations
  • Candidate scoring + optimization layer to compare multiple possible edits or outputs instead of accepting the first response
  • Execution bridge that maps the approved plan back into the existing feature pipeline

In practice, the agent workflow looks like this

  1. The current feature state is normalized into a shared graph.
  2. Relevant memory and recent context are retrieved from Supabase.
  3. Gemini generates a structured plan, not freeform text.
  4. That plan is validated against allowed actions, node types, and graph constraints.
  5. The system scores candidate mutations and selects the best valid option.
  6. The chosen mutation is applied to the feature workflow.
  7. The existing pipeline executes only when the user explicitly requests execution.

That shared graph layer is what made the system flexible. For example, Feature 1 exposes stages like upload, transcription, generation, hook filtering, and results, while Feature 2 exposes prompt, script, voice, gameplay, caption, and render stages. The agent sees both through the same abstraction, which means we can support multiple workflows without building a separate agent architecture for each one.

Fail-closed design

We also designed the system to fail closed:

  • If retrieval fails, the app still works without memory.
  • If Supabase is unavailable, the agent can still run statelessly.
  • If Gemini returns malformed output, the mutation is rejected.
  • If execution is not explicitly requested, the agent only updates the workflow and does not run the pipeline.
  • If the agent is disabled entirely, the manual workflow still runs exactly as before.

That architecture matters because it keeps the system agentic without making it brittle. The AI layer improves planning, adaptation, and optimization, but it never becomes a single point of failure for the product.

Challenges we faced

The hardest challenge was making the system feel intelligent without letting it become destructive.

A lot of AI demos look good only because they avoid real constraints. We did the opposite. We forced the agent to operate through typed workflow actions, validation rules, bounded custom block creation, and an execution bridge into existing feature logic. That meant more engineering complexity, but it also meant the product stayed explainable and reliable.

Another challenge was balancing flexibility with usability. We wanted Shorty to feel like a creative assistant, not a rigid automation tool. The answer was making the workflow visual and editable, so users keep control while the agent handles the heavy lifting.

What we learned

We learned that the most useful AI systems are not the ones that hide everything, but the ones that turn complex reasoning into something visible, editable, and safe.

We also learned that “agentic” should not mean uncontrolled autonomy. In our case, it means structured planning, validated graph actions, candidate scoring, and safe execution. That made the product much more credible technically and much more usable in practice.

Why this matters for Canada

Shorty is our attempt to reduce the cost of producing high-volume, high-speed digital content in Canada.

If Canadians already consume user-generated content at massive scale, then helping Canadian creators and small teams produce more of it, faster and with better tooling, is a real economic and cultural opportunity. Shorty does that by turning content creation from a manual art into an editable, agent-driven system. (Statistics Canada)

If you want, I can also turn this into a more Devpost-polished version with stronger startup tone and shorter paragraphs.

Built With

  • ai
  • and-delivery;-google-gemini-for-ai-planning/script-generation
  • and-react-router-for-the-frontend;-node.js-+-vercel-serverless-api-routes-for-the-backend;-supabase-for-authentication-and-postgres-backed-storage;-cloudinary-for-video-upload
  • cloudinary
  • elevenlabs
  • elevenlabs-and-gemini-tts-for-voice
  • gemini-api
  • javascript
  • mediapipe
  • node.js
  • openai-api
  • openai-compatible-whisper-transcription
  • openrouter
  • postgresql
  • react
  • react-19
  • react-router
  • supabase
  • transformation
  • typescript
  • vercel
  • vite
Share this project:

Updates