The job was the kind most product teams get handed eventually: put real AI video editing into our product. Our users wanted captions without typing them, background removal without a green screen, and touch-ups without retakes. It took us three attempts, and two dead-ended.
The first attempt wired AI services around a basic player. The transcription API sent captions back as a sidecar file, and we wrote the code to parse, sync, and style it. Background removal came back as finished video — pixels, not a cutout, nothing to adjust. Each platform wired the same services its own way, so two features on three platforms was six integration projects, and we were maintaining plumbing instead of a video product.
The second attempt tried to generate the whole video. Describe it, get it. The outputs were never the same twice. The near-miss killed it: a mostly-right video with wrong pacing had nothing to open and fix. No project, no timeline, no clip to drag — just the prompt.
What worked changed the shape of the thing. We stopped wiring AI around an editor and started using an SDK where the AI features are part of the engine itself: Meishe’s platform.
What Meishe’s SDK Gives You
AI captions land on the timeline as editable text. AI captions generates the text from the speech and puts it on the timeline with its timing, where you can fix any word. In our app, a misheard product name gets clicked and fixed by the user, in place — no sidecar file, no syncing step on our side.
AI smart editing finds the usable parts. AI smart editing scans the footage, finds the usable parts, trims the dead air and orders the clips — you approve or adjust. A user drops in twenty rambling takes and gets back an ordered cut to react to, instead of scrubbing through all of it with the trim tool.
AI Vlog turns a day’s footage into a first cut. With AI Vlog, you point the camera or drop in your footage and it turns into a vlog-style video — highlights picked, cuts made, music and captions on. The thing our users used to attempt by hand on a Saturday comes out as a vlog they can open and tweak.
Background removal is a toggle on the clip. Not a returned video; a switch with a live preview. Keep it, drop it, layer the cutout onto new footage. When the edge needs adjusting, there is an actual thing to adjust.
The editor around these is an embeddable multi-track timeline with keyframes and styling that we re-skinned to our product’s look. The engine underneath is one C++ core built for each place we ship: right in the browser, natively on iOS and Android, and on our servers for rendering. The AI features live inside that engine, not wired to it from outside.
Two pieces of the stack matter beyond the editor. The projects are structured files a program can read and change, and Meishe ships skill packages that let AI coding assistants like Codex, Cursor, and Claude Code use the SDK directly — so the tool that writes our app code can also assemble a video project. And there is a batch queue: a scheduler plus render workers that runs hundreds of renders overnight. The same project always renders to the same video, so re-rendering a fix never changes anything else.
Meishe’s Advantages
The switch that mattered was where the AI lived. Inside the engine, the captions are a text track the engine already knows how to place, time, and style; the syncing code and the caption renderer simply never got written. Outside the engine, every feature was a vendor, a wiring job, and a per-platform bug list. The same property fixed Attempt 2’s near-miss: because there is a project file, a mostly-right video is something a person can open and finish.
The second advantage is platform arithmetic. One engine, built separately for each platform, means one SDK to embed per surface and every feature comes along — not six integration projects that restart with each feature. Web, iOS, Android, desktop, and the render queue get the same behavior, because it is the same code.
Both creation modes sit in one platform. The editor serves the users who edit by hand; the pipeline and the batch queue serve the flows that should run themselves. They share the project format, so a human pass and an automated pass are one file-open apart. Deployment is private, too: the whole thing runs on our own servers, on-premise or in our cloud, so user footage never takes a trip through someone else’s machines.
How Cooperation Works
The path we took is the one the SDK offers. First, the editor demo — free to try. We opened it with our own footage and checked the captions, the cutout, and the editor feel against what our users ask for. That single afternoon replaced weeks of guessing.
Then a technical discussion with the Meishe team, on platforms and integration scope. After that, the commercial licensing discussion, with terms worked out directly between the teams.
Deployment landed on our own infrastructure, on-premise or in our cloud. The engine, the AI features, and the render queue all run inside that perimeter.
Common Questions
What about generative video tools? We tried that road. The outputs were never the same twice, and a near-miss had nothing to open. A structured project that renders identically is what makes iteration possible; generation can be a step inside it, not the whole pipeline.
Which platforms does the SDK cover? The engine runs right in the browser, natively on iOS and Android, on the desktop, and as the server-side rendering pipeline. One core, built for each surface.
Can the editor carry our branding? Yes. The editor’s styling re-skins to the product’s look. Our users see our interface.
Do the AI features need outside services? No. The AI products come built into the engine. There is no transcription vendor, no background-removal endpoint, and no second set of API keys to manage.
Can automated and manual editing coexist? Yes, on the same project format. A batch job renders the overnight volumes, and any project opens in the editor for a human pass. The handoff is one file-open.
How do you evaluate it honestly? Judge every AI feature by what a user can do to its result after it arrives. A text track, a toggle, and a dial pass that test; a returned video file does not.
Three attempts, two dead ends, and one stack that held. What finally worked was an SDK where the AI lives inside the engine: captions as editable text, cutouts as toggles, projects as files that code and coding assistants can write, one core running on every platform we ship, and all of it on our own servers. That is the guide we wish we had been handed at the start.