Inspiration
KlipCut started because I had a problem that was driving me crazy.
I had hours of footage from gaming, job sites, and everyday life. Somewhere inside those recordings were funny moments, useful explanations, before-and-after transformations, and clips worth sharing. Finding one good moment meant watching hours of video again.
Before KlipCut, the project was called Intelligence Clipper.
The original goal was simple: use local AI to watch videos, describe what happened in each scene, and create a searchable record of the footage.
I searched the internet for something that could already do this. I could not find a complete solution. Then I went to OpenAI and asked for help finding one.
OpenAI could not find one either.
So I asked:
Could we build it?
The first proof of concept used LM Studio, an RTX 3070 Ti in my old gaming computer, and Immich as my self-hosted photo and video library.
It proved that local AI could understand my footage, but it also exposed the limits of my hardware. I did not have enough VRAM for the models and context required for reliable video understanding, and I could not run the vision model and transcription services at the same time.
GPUs with enough memory normally cost several thousand dollars. Then I discovered the Intel Arc Pro B70, which offered 32 GB of VRAM and strong video capabilities at a price that made the project possible.
The new GPU architecture would not work in my old computer, so I started pricing a completely new workstation. Instead, I found a more unconventional option: a used Dell R740 enterprise server.
The server could hold three Intel GPUs.
When someone goes on a hardware spending spree, they rarely stop at “one is enough for testing,” so naturally, I bought three.
All that new capability left me asking a bigger question:
What else could we build?
Through many conversations with ChatGPT, Intelligence Clipper grew from a searchable video experiment into KlipCut: a platform designed to help people understand raw footage and turn it into finished content.
What it does
KlipCut helps small businesses and creators turn the footage they already capture into organized, editable, and exportable content.
The Build Week demonstration follows a real small business, Southern Tree, with their permission.
The demonstrated workflow includes:
- Southern Tree requests access to KlipCut.
- KlipCut creates a workspace for the business.
- The platform reviews the company’s public website.
- It extracts supported business facts and shows where the information came from.
- The owner confirms or corrects the information.
- KlipCut asks for additional context that cannot be learned from a website.
- Real job-site footage is uploaded.
- KlipCut processes the media and creates a Studio editing session.
- The footage is placed into a working timeline.
- A real render job is created, tracked, and completed.
- The finished video is saved for the business to use.
The goal is not to remove the user from the creative process. The goal is to remove the unnecessary friction surrounding it.
I can capture footage, and Southern Tree can perform excellent work, but neither of us should need years of editing experience, an agency, and several disconnected subscriptions just to turn that work into useful social content.
How we built it
KlipCut combines a web application, media-processing services, local AI infrastructure, and GPU-accelerated model serving.
The platform includes:
- A customer onboarding and access workflow
- Business-profile and context management
- Website-based business research with source review
- Media upload and intake
- Background processing and job tracking
- Video understanding
- A timeline-based editing environment
- Render and export management
- Local model serving
- AI gateway and runtime health tooling
The frontend was built with React, Next.js, TypeScript, and Material UI.
The backend uses Python, FastAPI, PostgreSQL, Redis, SQLAlchemy, and Alembic.
FFmpeg handles core video-processing and rendering tasks. Docker is used to deploy and manage the different application services.
The local AI infrastructure runs on Intel Arc Pro GPUs using tools including OpenVINO and OpenVINO Model Server.
The Intel GPUs themselves have been great. However, because the hardware architecture and surrounding open-source ecosystem are still relatively new, many established AI tools did not yet support the exact workflows I needed.
Instead of abandoning the hardware, Codex helped me build the missing software layer.
That work included:
- Model-loading and runtime configuration
- AI request routing
- Video-understanding integrations
- Service-health visibility
- Hardware-aware model serving
- A consistent gateway between KlipCut and the models underneath it
That gateway work also became part of Aegis, a separate application that helps operate and coordinate models, services, agents, and hardware.
Aegis manages parts of the operational layer. KlipCut remains focused on the customer-facing content workflow.
How GPT-5.6 helped
I used GPT-5.6 to:
- Shape the product direction
- Challenge weak ideas
- Work through architecture decisions
- Design the customer workflow
- Troubleshoot technical and product problems
- Break large goals into executable development plans
- Coordinate the work required for an end-to-end demonstration
How Codex helped
Codex worked directly inside the repositories to:
- Implement frontend and backend features
- Trace failures across multiple services
- Repair integrations
- Write and run tests
- Inspect logs and runtime behavior
- Refactor systems as the architecture evolved
- Document completed work and remaining issues
- Continue extended coding sessions from outcome-based instructions
The night before the deadline, running on almost no sleep, I gave Codex the end goal and asked whether it could continue working while I slept.
It did.
Challenges we ran into
The first major challenge was hardware.
Video understanding requires significantly more model memory and context than a normal text workflow. My original RTX 3070 Ti could prove the concept, but it could not reliably support the complete pipeline.
The next challenge was software compatibility.
The Intel GPUs gave me the memory and performance I needed, but many open-source AI tools were primarily designed around more established GPU platforms. Some integrations were incomplete, some behaved differently, and some did not yet support the environment at all.
That forced us to build more of the operational layer ourselves.
Another major challenge was scope.
A system that describes a video is much simpler than one that:
- Understands a real business
- Manages uploaded media
- Tracks background processing
- Serves multiple AI models
- Creates editing sessions
- Maintains project state
- Renders final videos
- Remains understandable to a nontechnical user
The timeline editor was especially difficult. A timeline looks simple on screen, but it requires coordination between playback, clip state, user interaction, project persistence, media processing, and final rendering.
There were several points where I probably should have accepted that the idea was too large.
Instead, I kept looking for unconventional ways around each limitation. Sometimes that meant changing models, rebuilding infrastructure, buying used enterprise hardware, or creating tools that did not exist yet.
The final challenge was time.
This was an existing project that we meaningfully extended during Build Week. The final submission required turning a large, evolving platform into one understandable demonstration before the deadline.
Accomplishments that we're proud of
The accomplishment I am most proud of is that KlipCut moved beyond being a technical experiment.
It now demonstrates a real end-to-end workflow:
Real business → confirmed context → real footage → processing → editing → rendering → finished video
Southern Tree allowed us to use their real business, branding, and footage in the demonstration. That transformed KlipCut from a product shown with placeholder data into a platform solving a real problem for a real customer.
I am also proud that the project runs on hardware I own and control.
The Intel Arc Pro GPUs made the local AI infrastructure financially possible, and Codex helped us build around the areas where existing tooling did not yet meet our needs.
Most importantly, the original idea worked.
We started by asking whether local AI could understand hours of footage and make it searchable. That capability became the foundation for a much larger product that can help turn footage into something useful.
What we learned
The biggest lesson was that a capable AI model is only one part of a complete product.
The systems surrounding the model matter just as much:
- Reliable media ingestion
- Progress visibility
- Model routing
- Hardware management
- Customer context
- Clear user controls
- Project persistence
- Rendering
- Error recovery
- A workflow people can understand
I also learned that unconventional solutions are often the reason an ambitious project becomes possible.
A used enterprise server and newer Intel GPUs were not the obvious path, but they gave me the resources to continue building when traditional options were financially unrealistic.
GPT-5.6 and Codex also changed how I approach software development.
GPT-5.6 helped me reason about the system at the product and architecture level. Codex could then enter the repository and turn those decisions into working implementation.
That combination allowed me to attempt a project much larger than I would have considered achievable on my own.
I originally started building KlipCut because I never had enough time to search through footage or properly learn video editing.
Based on the quality of my rushed submission video, I clearly built it just in time.
What's next for KlipCut.io
The next step is turning the demonstrated workflow into a dependable production experience for real customers.
Planned work includes:
- Improving automatic video understanding
- Identifying valuable moments without requiring users to watch everything
- Expanding timeline, audio, and editing tools
- Generating captions, titles, calls to action, and platform-specific content
- Creating reusable brand and business memory
- Helping businesses decide what footage they should capture next
- Building publishing and campaign workflows
- Connecting content creation to measurable customer-acquisition goals
- Continuing to optimize local AI performance on Intel hardware
- Expanding the AI gateway and Aegis operational layer
- Onboarding additional small-business customers
KlipCut began as a way to search video.
It is becoming a system that helps real businesses turn the work they already do into content they can actually use.
The tool I needed did not exist.
So we built it.
Built With
- alembic
- api
- codex
- docker
- fastapi
- ffmpeg
- gpt-5.6
- immich
- intel
- linux
- model
- next.js
- openai
- openvino
- postgresql
- python
- qwen
- react
- redis
- rest
- sqlalchemy
- typescript
Log in or sign up for Devpost to join the conversation.