Tighten Episode

The Tighten Episode node cleans up a podcast or interview recording in one step. It transcribes the recording, removes silences, filler words and false starts, and renders the tightened episode. It can also add captions and a music bed.

Inside, the node runs the same steps that you can wire by hand: Transcribe with speaker labels and word timings, Silence Detect, Edit Plan in Tighten mode and Apply EDL. When you turn them on, it adds Add Captions and a music bed with Mix Audio and Merge Video & Audio. Each step runs as its own job, so a long episode, a cancel or a failure behaves as it does in a hand-built workflow.

Tighten Episode runs its planning step on Nodaro Cloud, and its render too when you choose a framing. On a self-hosted install, connect the install to Nodaro Cloud, under Integrations › nodaro.ai or with an API key. Without a connection, the node is not offered and a run is refused before anything starts.

When to use it

• Clean up a raw interview or podcast recording before you publish it.
• Make an audio-only podcast episode from a video recording.
• Make a vertical, speaker-framed cut of a two-person video podcast.
• Add a music bed under the whole episode.

Use the individual nodes, such as Edit Plan, Apply EDL, Camera Switch and Speaker View, when you need more control. That includes several cameras, a hand-edited plan, short clips or chapters.

Quick start

The template marketplace has two ready workflows. Tighten Episode is the hand-built chain of Transcribe, Silence Detect, Edit Plan and Apply EDL, ready to fill. Tighten Episode in One Node is this node, with Review before render on and word-highlight captions.

Inputs

A recording that is longer than 3 hours, a recording with no sound, or a music file that cannot be read as audio is refused before anything is charged.

Outputs

Settings

Framing

With Framing set to a shape, the node renders the episode with Speaker View instead of Apply EDL. When two to six speakers share the camera and the shape is not 16:9, each speaker on screen gets an automatic box. Otherwise, the camera is shown full frame. The node does not track faces. The Layout list offers only the layouts that Speaker View draws at the chosen shape.

Review before render

With Review before render on, a run stops at a preview of the cut. The render is a Preview, at the lower preview rate, and the captions and the music bed are not added yet.

1. Open the review and check the cut. You can hear any cut, restore what the plan removed and cut what it kept. See Reviewing a cut.
2. Click Render final on the node. The node renders the episode at full quality with your edit, then adds the captions and the music bed, once.

• Render final uses the settings of the preview. To change a setting, run the node again.
• You can render final again. After a Render final has finished, edit the cut again and click Render final. The render and the steps after it run and are charged again, with no fee. Rendering the same edit a second time is refused, and only one Render final runs at a time.
• In a published app, the node shows its preview on the app's page with a Render final button, as an Apply EDL render does. Once a final is made, another Render final of the same run is refused. See Render final in an app.
• The nodes after it run on the preview. On Nodaro Cloud, the node stops at its preview, but the nodes connected after it run on the preview and are charged. They run again on the final episode at Render final.
• Someone has to review. A run with nobody to review it cannot pass the node. That includes a run started from the API, the SDK, the MCP run_workflow tool or a trigger, and a run inside a component. The nodes before Tighten Episode run and are charged. The node then fails with preview_review_required, with nothing charged for it. Turn Review before render off for those runs.
• Not once per list item. A node with Review before render on that is fed by a List is refused before any of its runs starts, with nothing charged. The message reads: "Review before render isn't available when the node runs once per list item — turn it off to run the list."

The MCP tools tighten_episode and continue_use_case are reviewed by the AI assistant that calls them, so they can use Review before render.

If a run fails

The steps that finished stay finished. Their results, such as the transcript and the edit, are kept, and they are not charged again. Press Continue on the node: only the step that failed and the steps after it run again.

A node fed by a List runs once per item. It has no Continue or Render final button, so run it again instead.

Credits

Tighten Episode charges each step at its own rate, the same as the node it stands for, plus a small per-run fee. The node shows the full estimate, fee included, before you run.

• The per-run fee is charged once per run. A Render final after a review is not charged the fee again. A failed run's fee is refunded, and Continue holds it again.
• A List runs each item as its own run, with its own fee.
• You are charged for the rendered episode's own minutes, not for the estimate.

The estimate before you run

The estimate prices the render at the full length of the recording. The tightened cut is shorter, so the render is charged less than the estimate shows. A recording with no known length is estimated at the 180-minute ceiling. With a framing, Speaker View is estimated at its higher rate until the edit is known. A cut with at most two speakers on screen and no zoom is charged the lower rate.

How Edit Plan counts the minutes is explained on Edit Plan.

Tips

• Review important episodes. Turn on Review before render, check the cut, edit it, then click Render final.
• Reuse the edit. Wire the Edit (EDL) output into a second Apply EDL node to render the same cut in another format.
• Steer the plan. Use Instructions for what the plan should keep or remove, for example keep the cold open.
• Draft on Economy. Use Economy for a quick first pass, and a higher Editing quality for the episode you publish.

Troubleshooting

From the API

POST /v1/tighten-episode starts a run and answers 202 with jobId and executionId. The body takes mediaUrls (one recording URL), and optionally musicUrl, output, framing, captions, captionStyle, reviewBeforeRender, planTier, instructions, styleGuide and musicDuckAmount. Poll the job with GET /v1/jobs/:id/status.

• The job's output_data carries the episode (videoUrl, or audioUrl for an audio episode), the edit (json), the transcript and quality (proxy for a preview, final otherwise). A failed run keeps what completed and names the failed step in failedStep.
• An Idempotency-Key header makes a retry of the same request answer with the same jobId and "deduped": true, and start nothing.
• POST /v1/tighten-episode/estimate takes the same body and answers { data: { totalCredits, stepsCredits, feeCredits, durationSec } }, without starting anything.
• POST /v1/tighten-episode/continue with { jobId, mode } continues a run. "mode": "from-failed" runs what a failed run did not complete. "mode": "render-final" renders a review run's final, with an optional editedEdl. A Render final of a run that was not a preview answers render_final_not_preview, and one of an edit already rendered answers render_final_already_rendered.

The SDK (client.edit.tightenEpisode, client.edit.estimateTightenEpisode, client.edit.continueUseCase), the CLI (nodaro edit tighten-episode, nodaro edit continue-use-case) and the MCP tighten_episode tool call the same routes. See Run a single node, Editing in the SDK and the MCP analysis and EDL tools.