Under the hood

Read from the app’s source code when this page is built. Descriptions are in English, the way your AI sees them.

get_project

Get the project structure: tracks, clips (ids, positions in seconds, and the picture size for video clips), levels, markers for earlier automatic edits, the vocabulary (names given to the speech model), and the transcription: transcribed is true only when every recording with speech is transcribed; transcription says exactly how far it is (done of total, the one running now, waiting, held = recordings imported without automatic transcription ("ikke transskriberet (slået fra)", start them with transcribe), failed and why, or why nothing runs); footage says the same for the footage analysis. Call this first.

get_transcript

Read the transcript as it sounds on the timeline now (after edits). Times are timeline seconds. Use format 'words' or 'timed' to get each word's number "i" (for delete_words; it moves when words before it are hidden or cut) and its fixed id like "3.136" (for correct_word). For choosing or cutting speech in a story or interview use read_story_script instead. Minutes of a meeting or interview: read the default text format (each turn starts with [minutes:seconds] and the speaker), then call set_summary with a short summary (3-6 sentences, same language as the meeting), decisions, tasks (who, what, deadline) and open questions, each with the time it is said; only what is actually said. Long recordings: read it in parts with from_seconds/to_seconds.

transcribe

Transcribe all audio that is not transcribed yet, with word timestamps and speaker detection. Runs locally; can take a few minutes for long recordings.

quick_transcribe

Quick transcription of many or long recordings (e.g. a course over several days, a long meeting) into ONE long text in order, without putting them in the project: only text, fast settings, no cleaning or editing. Each file gets a heading (name, recording time, length); paragraphs per speaker change with timestamps. Speakers simply as main speaker and 'Deltager' (default) or all voices; voices are recognised across files. Saved as Word/text/Markdown (written again after each file, so it can be read while it runs). Runs in the background: the answer comes at once; call again without files for progress and time left, stop=true to stop (finished files are kept; start again with the same files to continue). Measured 20-35 times faster than real time on an M1 Max (2.5 hours in about 5-8 minutes; slower while other heavy programs run); tell the user the estimate in the answer.

transcribe_range

Transcribe only a time range again (timeline seconds; e.g. where words are missing or wrong) and replace the words in that range. The new words keep the speaker and the sentence ends of the old text where the new transcription has none (a range that ends in the middle of a sentence gets no false full stop), a word just outside the range is not added twice, and corrections of later words follow along. The range is widened to whole words (a word across the edge is transcribed whole). It is conservative: an old word the new transcription does not have is kept wherever there is speech in the sound there (near the edge always); a word is only removed where the recording is quiet, so real words are never silently lost. A new reading the model is unsure of (also when one word becomes two) never replaces an old word; the answer names it, so it can be set with fix_text. The new transcription is not an undo step (undo undoes the last edit before it); correct its text with fix_text. Only the speech track is transcribed again (not B-roll or sound from the location). The answer lists the words removed, added and kept, and starts with ADVARSEL if words disappeared. Afterwards word numbers and ids (get_transcript) and sentence numbers (read_story_script) in and after the range may have changed: read them again before you correct or cut. verbatim=true writes repetitions and broken-off words as said (e.g. 'var ikke var ikke'). It listens to fixed pieces of the recording (split in the longest pauses, the same whatever the exact range, so no word is cut at the edge), three times each with different margins, with the words before as context, and the words the majority hears win; a slightly different range or running it again gives the same text. Text corrected with fix_text in the range stays. If a word is still missing or wrong, correct it with fix_text instead of running this again.

find_untranscribed_speech

Find speech the transcript may have missed: stretches of at least 0.4 s of voiced speech (not breath or hiss) inside a sentence but with no words, words that last far longer than their letters suggest (the model often swallows a repeated word), and speech without words that has been cut away right next to a cut (up to 2.5 s from the cut in the recording; shown as cutSeconds and cutAwayInRecording: it may belong to the sentence). Marks them on the timeline by default. Try transcribe_range with verbatim=true there (for speech cut away: undo the cut or transcribe the recording again around it) and read the text again before you cut.

find_noises

Find sounds without words: coughs (Danish 'host'), sneezes ('nys'), hiccups and burps. The transcript never contains them, so they are found in the audio: short loud stretches without words that the Mac's own sound classifier recognises. Returns each with timeline seconds, label (host/nys/hikke/bøvs), confidence and peak level compared to the speech (dB). Remove them with remove_noises.

remove_noises

Remove sounds without words (coughs, sneezes, hiccups, burps) found by find_noises: all of them, or only those starting at the given timeline seconds. The sound is followed out with its tail, a throat-clearing or "hm" right after a cough is taken too (never words), and the cut lies at the quietest place just outside the sound, so the clip after it does not start with a click. One undo step.

suggest_edits

Preview automatic edits (fillers, repetitions, long pauses) without changing anything. Returns each proposed cut with time and reason. A pause is only tightened where the sound is silent; a pause with sound in it says so in its label (e.g. '9,1 s med lyd i; 1,7 s stille kortes').

apply_auto_edit

Apply automatic edits: remove fillers, repetitions and/or tighten long pauses. Pauses are only tightened where the sound confirms the silence, with a little silence left on each side; generated speech (elevenlabs_speak) is left alone unless include_generated_speech is true. Everything becomes one undo step and is marked on the timeline.

prepare_podcast

Prepare the whole project for a podcast in one step: transcribe what is missing and clean the sound at the same time (standard chain), then remove fillers, repetitions and long pauses, and even out the level. Each part is one undo step. Use this first for requests like 'make it ready for podcast'; then use find_retakes/review_retakes, get_transcript and delete_range for editorial cuts.

review_retakes

Review all retakes (sentences the speaker started over) at once: every group with the text and times of each take and a suggested take (the last one, usually the complete one). With apply_suggested=true the suggested takes are kept right away (one undo step). Otherwise judge them and call keep_takes.

find_retakes

Find sentences the speaker started over (retakes). Returns groups of takes with their text and times, so you can judge which take is best. Then call keep_takes.

keep_takes

Keep one take in each retake group from find_retakes and remove the others. One undo step, marked on the timeline.

delete_range

Cut out a time range on all tracks and close the gap. In speech, each boundary is moved to the nearest pause between words (at most 0.5 s, never into a word; the answer says what moved), and a boundary in speech without a pause nearby is refused. A sound without voice between words (a knock, paper) can be cut. A boundary in an empty gap between two clips takes the whole gap along, so no digital silence is left. For choosing or cutting speech by meaning, use read_story_script and apply_story_script instead.

delete_words

Delete words from the transcript (and the audio) by index, including the pause after them. Get indices from get_transcript with format 'words'.

split

Split all clips at a time.

move_clip

Move a clip in time and optionally to another track (e.g. to place music, or to gather speech on one track), or with track_id "new" to a new track right under its own (e.g. a camera that lies after another camera on the same track gets its own track this way). Overlapping clips on the same track crossfade automatically. If the track it came from is left empty (and has no plugins or settings of its own), that track is removed in the same undo step.

trim_clip

Change a clip's in and out points (timeline seconds). An edge made shorter where the clip touches another clip on the same track is cut out like delete_range: everything after moves along, so no gap of digital silence is left between the clips (the answer says how much moved). If the clip has speech, a point that moves is moved to the nearest pause between words (at most 0.5 s, never into a word; the answer says what moved), and a moved point in speech without a pause nearby is refused. A point is never moved into or past a word the clip did not have: lengthening into such a word puts the edge in the pause before it, and the answer says that the wanted time could not be reached and why. Only the point that moves is checked: give the other one unchanged (within 10 ms). To give the very end air after the last word, prefer fade_out_end or apply_story_script (which ends with air after the last word); nothing can lie before 0 s, so for air before the very first word use apply_story_script (which always starts with air). If nothing would change, nothing is done and the answer says why.

set_fades

Set fade in and fade out length on a clip (seconds).

delete_clip

Remove a whole clip (without closing the gap).

set_track_level

Set a track's level in dB.

set_clip_level

Set a clip's overall level in dB.

set_level_points

Draw a level curve on a clip with points, e.g. to fade music up and down at specific times.

duck_under_speech

Lower a track (usually music) automatically whenever someone speaks on the other tracks, with smooth fades. Undoable.

set_track_solo

Solo a track (only solo tracks are heard) or turn solo off.

list_plugins

List the audio plugins (AU/VST3) installed on this computer.

add_plugin

Put a plugin at the end of a track's plugin chain. The user can open its window in the editor to adjust it.

remove_plugin

Remove a plugin from a track.

set_plugin_bypass

Turn a plugin off (bypass) or on.

get_plugin_parameters

List a plugin's parameters: id, name, unit, min, max, current value, and value names for choices. Use set_plugin_parameter to change them (e.g. turn down the strength of a noise reduction plugin).

set_plugin_parameter

Set one or more plugin parameters at once. The plugin's new settings are saved in the project as one undoable step.

list_plugin_presets

List a plugin's presets: factory presets (number 0 and up), user presets (negative numbers) and the current one.

load_plugin_preset

Load a plugin preset. The plugin's new settings are saved in the project as one undoable step.

set_track_muted

Mute or unmute a track.

import_audio

Import an audio file (the main recording of a podcast or interview, or music or a jingle) or a video file (.mov, .mp4; needs the Studio license) onto a new track starting at 0 s, or with track (and at_seconds) onto an existing track, e.g. the speech track, so no new track is made. Use it for the main recording too when the project is empty. A video's picture follows its sound: cutting the audio or the transcript cuts the picture too. Use move_clip, set_track_level and set_fades afterwards to place it. It is transcribed by itself in the background unless transcribe is false or the user turned that off in the settings; then get_project says "ikke transskriberet (slået fra)" and transcribe starts it.

move_track

Move a track to another place in the track order (0 is the top). One undo step.

remove_track

Remove a track. An empty track is removed at once; a track with clips only with force: true, and the answer says which clips and recordings disappear. One undo step. Use it to tidy up empty tracks left after moving clips.

clean_audio

Clean audio locally: noise reduction (light = at most 6 dB, medium = 12 dB, strong = 24 dB; optionally extra noise reduction and keep_character), calm background between words, room reverb removal (dereverb), rumble removal (rumble: a gentle high-pass below about 80 Hz for wind and traffic outdoors), broadcast voice (EQ, de-esser, compressor), level evening, and for old tapes: hum removal, click and dropout repair, careful treble lift and wow/flutter correction. Use analyze_tape first for tapes. ONLY WHAT YOU ASK FOR IS SWITCHED ON: e.g. {noise: "light", calm: "light"} gives exactly noise reduction and calm background, no voice EQ/compressor and no level evening. With no cleaning option at all, a default is used: in a story (indslag) the gentle one (light noise reduction and light calm background; outdoors, when the noise between words is close under the words, the very gentle one: only 3 dB noise reduction, because calm background there makes words harder to understand; plus remove rumble below 80 Hz when analyze_room finds wind or traffic rumble), otherwise the podcast default (medium noise reduction, broadcast voice and level evening). The answer says what was switched on. Without track_ids only the speech tracks are cleaned (never B-roll, music or the place's own sound). Fine-tune with the advanced values (own voice EQ, de-esser, compressor, noise/calm dB, dereverb amount, level target); leave them out for the defaults. Replaces any earlier cleaning of the same recordings with this one (undoable). noise: "none" with nothing else restores the original.

list_recipes

List saved recipes (reusable workflows such as 'Klar til podcast').

run_recipe

Run a saved recipe on the whole project.

export_transcript

Export the transcript (what is on the timeline now) as text: Word (.docx), PDF, plain text, SRT or VTT subtitles, or JSON. With title, date, duration and participants at the top, speaker names, timestamps and a note that the text is machine-made. Rename speakers first with rename_speaker so the names are right.

set_summary

Save a summary (minutes) of a meeting or interview in the project, where the user sees it and can export it. Make it from get_transcript (format "text" has [mm:ss] timestamps): a short summary, decisions, tasks (who, what, deadline) and open questions, each with the time it is said. Only include what is actually said. Replaces an earlier summary (undoable).

list_voice_profiles

List the voice profiles: saved cleanings for perfect speech (built-in and the user's own), with their choices, plugins, loudness target and an explanation.

save_voice_profile

Save a voice profile: from a track's current cleaning and plugins (from_track_id), or from an explicit cleaning. Explain the choices in 'description'. To find good settings first, use compare_cleanings and rate_quality on a typical excerpt, or create_voice_profile_from_audio.

apply_voice_profile

Apply a voice profile: clean with its choices and put its plugins (with their settings) on the track. One undo step per part.

create_voice_profile_from_audio

Make a voice profile from a typical excerpt: tries the built-in profiles (and Mac voice isolation if available) with compare_cleanings, rates them, saves the best as a new profile with an explanation, and answers with all scores. The excerpt is not changed. Apply it afterwards with apply_voice_profile.

list_library

List the sound library: intros, outros, jingles, music and effects with id, name, kind, length (s), loudness (LUFS), tags and default fades, level and ducking.

add_to_library

Add an audio file to the sound library (it is copied in, measured and kept). Kind: intro, outro, jingle, music or effect.

place_jingle

Put a sound from the library on the "Jingler" track: at the start (the rest moves so speech starts as it fades), at the end, after a sentence (makes room, like insert_jingle) or on top at a time (nothing moves, so it plays over whatever is there). Between speech use insert_jingle. Uses its default fades and level relative to the speech; music is ducked under the speech. Undoable.

insert_jingle

Insert a jingle or other sound from the library between speech, e.g. between the host's introduction and the first panel answer: after the sentence with some quoted words (after_text), after the first sentence ending after a time (after_seconds) or before a speaker starts (before_speaker). The program always finds the border between two whole sentences (or a change of speaker) from the word times and the sound (the quietest spot, also when the words follow each other without a pause, as in generated speech), makes room on all tracks and pushes the speech after it later; a sentence is never cut. Give exactly one of after_text, after_seconds and before_speaker. Use place_jingle for the very start or end. The answer says where it went, the words on each side and how far the speech moved. One undo step.

list_formats

List the episode formats: intro, outro, jingle (every N minutes), music, voice profile, cut rules, loudness, export (mp3/wav, bitrate, artist, album, title with {nr}) and the next episode number.

save_format

Save an episode format (a recipe for a whole episode), from the open project (from_project) or from the fields. Library sounds and profiles by id or name.

apply_template

Use a template (episode format) on the open project: clean with its voice profile, transcribe what is missing, cut by its rules, remove coughs if the template does, even level, intro and outro, its graphics package (video) and the host's and guests' names (given to the speakers in the order they first speak). The project remembers the template.

run_format

Make a whole episode from a format in one go: (new project with the raw files,) clean with the voice profile, transcribe, cut by the rules, even level, intro, jingles, outro and music, then export with title and episode number. Takes a few minutes for long recordings. The episode number counts up afterwards.

merge_speakers

Merge two speakers in one recording when speaker detection split one person in two (or gave the journalist's words to the interviewee): every word from from_speaker gets into_speaker, and from_speaker disappears. Speakers are numbered as the user sees them and as in rename_speaker: "Taler 1" is 1, "Taler 2" is 2 (the number stays the same after renaming). Speaker numbers are per recording: give source (file name such as "C0012") when several recordings are transcribed. The answer names both speakers and the number of words moved. One undo step (undo brings both speakers back).

split_speaker

Split a speaker: words that speaker detection gave to the wrong person (e.g. the journalist's question and the interviewee's answer as one speaker) become another speaker. Give the sentences (numbers from read_story_script), or a stretch from a word (from_word/to_word, word ids from get_transcript) or from a time on the timeline (from_seconds/to_seconds); without an end it runs to the end of that speaker's turn. speaker is who it is ("Taler 1" is 1, also a speaker known from another recording); leave it out for a new speaker, optionally with name. Subtitles, the transcript and graphics follow. One undo step for the whole call. Read the text again afterwards: sentence numbers can change (the letter is the speaker's).

export_summary

Export the project's summary (minutes) as Word (.docx), PDF or plain text.

new_project

Start a new, empty project (no tracks, no recordings), e.g. before importing files or making speech, music and jingles for a new episode. Does not ask and never loses work: if the open project has a file, its changes are saved there first; if it has never been saved, it is saved as a backup in the folder "Ikke gemt" in the project folder, and the answer says where. Optional name.

open_project

Open a saved project (.lydprojekt file). Does not ask and never loses work: if the open project has a file, its changes are saved there first; if it has never been saved, it is saved as a backup in the folder "Ikke gemt" in the project folder, and the answer says where. The sound is loaded again from the original files and the project's sound folder.

save_project

Save the project. Give 'path' to save under a new name (required if the project has never been saved).

rename_project

Rename the project. If it is saved, the project file and its folder with audio files are renamed on disk so name and file match. If it has never been saved, save=true saves it with the name in the default folder; otherwise it only gets the name. If the name is taken, the error suggests a free name (e.g. 'Morgenkaffe 2').

undo

Undo the last change (any change, also the user's). Do not undo cleanings or other versions the user may want to compare with, unless the user asked for it: try alternatives with compare_cleanings, and keep the current version with save_listening_copy first.

get_history

List the undo history, newest first: step number, what was done, who did it (user, agent = the editor's assistant, mcp = you or another connected AI) and whether it is undone.

measure_loudness

Measure how the timeline sounds (after plugins, exactly as exported) in a time range: integrated loudness (LUFS), loudness range (LRA), highest true peak (dBTP), noise in the pauses (pauseNoiseDbfs: median in quiet parts of at least 150 ms; quietest10pDbfs is the 10th percentile of 100 ms RMS, which hits breaths when pauses are tight), number of 100 ms places with peaks over -1 dBTP, and short-term loudness (3 s) over time (at most 600 points). With per_sentence: LUFS for each sentence. Use it to check levels before and after edits.

set_script

Set the text that is read aloud (reading with a manuscript). Afterwards find_retakes, suggest_edits and apply_auto_edit use it: repetitions that are in the text are kept, words that are not in the text and start over are restarts. Undoable.

set_vocabulary

Set the project's vocabulary: names and place names that are said (e.g. people's names, "Søndervig", "Aalborg Akvarium", "fiskeauktion"), so they are spelled right and the same way every time. Used whenever speech is transcribed (transcribe, the background transcription after import, transcribe_range and transcribe_result): a heard word that is nearly a listed name is written as in the list; it does not change text that is already transcribed: run transcribe_range (or transcribe with again) where a name was wrong, or fix it with fix_text. The words replace the earlier list (an empty list removes it); at most 40 words. Examples: "Søndervigen" -> "Søndervig", "fiskeaktion" -> "fiskeauktion", "Aalborg Akvariet" -> "Aalborg Akvarium"; inflections such as "Søndervigs" and "fiskeauktioner" stay, and no word is added where nothing like it is said. A word the speech model hears quite differently gets those spellings in parentheses: "Claude (Clawd, klort)" writes "Clawd" and "klort" as "Claude" (only the spellings given; sound alone changes nothing, so "cloud" stays). One undo step. With all_projects true it sets the user's fixed vocabulary instead (names and words the user often says, used in every project and in quick_transcribe together with the project's list; not undoable). get_project shows both lists. The user can also set them in Tekst > Ordliste and in Indstillinger.

compare_to_script

Compare the transcript with the reading text: words said that are not in the text (with times; errors, restarts or fillers), words that are spelled differently than in the text (e.g. names), and words from the text that were not said.

models_status

List the local AI models: whether each is installed, its size and license, the installed and the newest version, and whether a newer version can be downloaded (the user downloads models in Settings).

analyze_room

Measure the room on the speech tracks only (before cleaning, first 10 minutes). The background is measured two ways, and the verdict says which is which: backgroundDb = NOISE BETWEEN WORDS, the background in the pauses near the words relative to the weak ends of the words (dB, above 150 Hz; what calm background must tell apart from the words; above -20 dB = loudBackground, then calm background is not used), and pauseNoiseVsVoiceDb = NOISE IN PAUSES relative to the average voice (dB, 150-8000 Hz, the same measure as compare_cleanings' pauseNoiseVsVoiceDb; always much lower, because the voice on average is far louder than the ends of the words). backgroundWithRumbleDb is backgroundDb with the rumble below 150 Hz. rumbleDb: the sound below 100 Hz in the pauses relative to the audible background in the pauses (wind, traffic); rumbles true means clean_audio with rumble: true is worth it. tailDb: reverb tail 50-200 ms after words ABOVE the steady background (dB relative to the end of the word; a dry room is about -30; -60 = nothing above the background); rawTailDb with the background. Steady traffic or wind outdoors is background, not reverb. 'reverberant' says whether dereverb is worth trying; 'verdict' explains it all in Danish.

rate_quality

Listening test (measurements, not ears): compare a time range as it sounds now with the sound before cleaning, plugins and level points. Measures voice preservation per band, noise in pauses, noise UNDER the speech, whether noise follows the speech (silent pauses but noise with every word), holes in the speech (over-suppression: hollow, 'wind tunnel'), warble (gains jumping frame to frame), phase loss (metallic), tonal peaks (hum, buzz, whine: frequency and dB above the surrounding noise, in pauses and under speech), musical noise, pumping, reverb tail and whether pauses were raised relative to the voice (e.g. by levelling). Also transcribes the range locally before and now (same speech model) and compares the words: words that become unintelligible ('brandstationen -> branden station') pull the score down hard and come first in the explanation. Only the speech tracks are measured: B-roll, music, the place's sound and room tone are added on purpose and are not counted as noise. Gives a score 1-5 (anything that sounds like a wind tunnel cannot score well), 'listenAt' (timeline seconds where the user should listen) and an explanation in Danish (Bedre/Værre/Stadig lines). Report what was measured, never just the score; look at view_spectrogram too, and ask the user to listen at the given times before concluding.

view_spectrogram

See the sound: a spectrogram image of an excerpt (at most 60 s; time across, log frequency 50 Hz-16 kHz up, colour = level in dB, same scale in all panels). Without 'variants': before cleaning (top), now (middle) and the difference (bottom: red = removed, blue = added, overall loudness change taken out). With 'variants' (1-based numbers from the last compare_cleanings, at most 3): the original and those variants stacked. Also returns the listening test for the same excerpt. Hum shows as horizontal lines, noise as a carpet, over-suppression ('wind tunnel') as holes and smearing inside the speech, reverb as tails after words. You cannot hear: use this together with rate_quality (and the listen tool, if it exists and its model is installed) before you say anything about how the sound is, and ask the user to listen at specific times.

get_guide

The editing handbook (in Danish) for this project: the common rules plus the guide for its kind (podcast, meeting/interview, video, story/indslag, several cameras). By default the kind follows the project; give kind when the project does not show it yet (an empty project before import is treated as a podcast), e.g. kind 'story' for a news story. The built-in chat gets the same text. Read it before a larger task, especially a story.

view_frames

See the result: small pictures of the timeline as it looks now (picture, B-roll, transitions, name tags, titles, title cards and subtitles composed), as one contact sheet with number and time under each picture, plus a line per picture saying which recording or B-roll is shown, which graphics are on, and the words spoken around it. Give exact times (each cut, each B-roll, each name tag) or a count spread evenly over a range. Graphics are drawn as they stand in the middle of their time (no fades). Use it before you say that B-roll, graphics or a crop look right; old pictures only prove the old state. One picture at a time is large (960 points wide); several are small. With source_id: pictures of one recording at seconds in that file, with the shot description and what the camera does at each (calm or panning), to choose the exact place for B-roll before place_broll, replace_broll or edit_broll. The pictures are of real people and are sent to you; the user can turn this off in Settings (then use the local picture descriptions and say you have not seen it).

contact_sheet

See all the footage at once: ONE contact sheet with one picture from every video recording in the project (or with per_shot one per shot change of the chosen recordings), numbered, with the file name under each picture and turned the way the program shows it (videos filmed upside down or lying down are shown standing up). The text lists each picture: recording, length, size, whether and where it is used on the timeline, the time in the file and the footage analysis' short description (and which interviewee is recognised in it). Use it to get an overview before planning B-roll or a story, then view_frames with source_id to look closer at one recording. The pictures are of real people and are sent to you; the user can turn this off in Settings (then use search_footage and footage_status).

set_color_look

Colour grade the whole picture (Studio): a finished look ("kølig" = cool, "varm" = warm, "neutral", "ingen" = as recorded) and/or changes ON TOP of it: temperature (negative = cooler, positive = warmer), contrast, saturation and brightness are added to the look's own values (e.g. look "kølig" and temperature -0.3 is cooler than kølig alone; without look they are added to the current look), and the strength of the whole look (strength_percent 0-100, e.g. 50 for a subtler look). The answer says the total effect and how it differs from before. Applies to playback, view_frames and Send ud; graphics are not changed. One undo step. Look at the result with view_frames before you say it looks right.

set_lut

LUT (.cube, 3D LUT from DaVinci Resolve, Premiere or Final Cut) on the whole picture (Studio), before the colour look. Without arguments: lists the user's fixed LUTs and the one in use. file: add a .cube file to the fixed list (copied into the program's own folder) and use it; name: use a fixed LUT by name ("ingen" takes it off); strength_percent: 0-100 (default 50); remove: delete a fixed LUT from the list. Creative LUTs are made for graded or LOG footage and are far too strong on phone recordings: use a low strength there (25-50 %) and look with view_frames. LOG-to-Rec.709 LUTs (conversion LUTs) only fit recordings filmed in LOG; on ordinary phone video they make the picture wrong, so do not use them there. One undo step.

fade_out_end

Fade the end out to black: picture (also graphics and subtitles) and sound fade to black and silence over the last seconds of the timeline, without clip ids. seconds: length of the fade (default: the air after the last word, 0.5-1.5 s; 0 removes it; at most 10). The fade never starts before the sound of the last word has ended (measured in the sound): with too little air the end is lengthened in the same step: the sound is room tone from the same recording (never speech), and the picture continues from the recording only when nobody speaks there; when the person goes on talking after the clip (or the recording ends) the picture holds still on the clip's last frame, so speech that was cut away is never seen or heard (or, when none of this is possible, the fade is made shorter); the answer says which. For a living picture at the end, lay B-roll over it. One undo step; also in Grafik > "Ton ud til sort".

transcribe_result

Hear the result as text: transcribe the timeline as it plays now (after all cuts, cleaning and plugins, with music and place sound) with the local speech model, and list every cut in the speech with the words heard on both sides. Only cuts on the speech track count: B-roll, music, place sound and the room tone at speaker changes are not cuts, pieces that continue each other in the same recording are not cuts, and a pause of room tone at a speaker change is one cut (where the pause starts), not two. With expected_text (the quotes you planned, in order) it also lists words that are missing (often cut off at a cut) and extra words (e.g. a stray word from the sentence before), and how much of the planned text is heard. Use it after cutting speech and before you say the story is finished; the speech model can mishear (and may also hear voices in the place sound), so ask the user to listen where something is missing. Takes a few seconds per minute.

save_listening_copy

Keep the current version for A/B listening: saves a time range as it sounds now (with cleaning and plugins, at most 10 minutes) as a sound file and shows it with a 'Lyt' button in the editor's log. Use it BEFORE you try something else on the project (another cleaning, plugins), so the user can compare. Never use undo to make room for a new version without asking the user.

listen

Listen to an excerpt with the local listening model (you cannot hear audio yourself): it describes in words what it hears - background noise, reverb, pumping noise in pauses, distortion and processing artifacts such as metallic, underwater or wind-tunnel sound. version: "now", "before" (before cleaning) or "both" (each heard on its own; compare the two descriptions yourself, the model cannot compare two clips). At most 30 s per piece; longer excerpts up to 120 s are split. Reliable for strong reverb, heavy distortion and heavy cleaning artifacts; it rarely hears noise lifted in pauses (check that with the spectrogram and rate_quality) and does NOT hear hum, whine or mild artifacts, often guesses the speaker's gender and age wrong, and 'no problems' is no proof. Use it together with rate_quality and the spectrogram, and ask the user to listen at concrete times. To DECIDE whether something is wrong, use judge_listen instead (measured 30/10: an open question with a list of possible faults made the model report faults in 8 of 8 clean excerpts). Takes 5-15 s per piece (about 20 s more the first time while the model loads).

compare_cleanings

Compare up to 6 cleanings on an excerpt (at most 60 s) side by side WITHOUT changing the project: built-in cleaning with different options and/or plugin chains with presets or parameters. This is the way to try alternatives (never undo the user's version to try another). Gives a table per variant: loudness, noise in pauses, score and the listening test's measurements (holes in the speech, warble, noise under the speech, tones, listenAt times), and how long it took. The original and each variant are saved as sound files and shown in the editor's log with 'Lyt' buttons so the user can listen A/B. Each variant is also transcribed locally before and after (same speech model): 'intelligibility' gives the share of words heard the same and the model's confidence (judged false: the speech model heard too little before the cleaning or gave up on this excerpt, so there is no verdict; say so and ask the user to listen), and words that become unintelligible (e.g. 'sommerhusene -> sommer usene') pull the score down hard. 'recommendation' names the best variant that keeps the speech intelligible: NEVER recommend a variant with lessIntelligible true, even with a good score. Only the speech tracks are measured (B-roll, music, the place's sound and room tone are left out on purpose). 'differsFromProject' says what the comparison does not include (the project's level points, plugins, and that only the excerpt is cleaned), so tell the user the result on the whole project can differ and check it with rate_quality afterwards. musicalNoisePromilleBeforeNow: short tonal remnants in the pauses (warble, little whistles), per mille of the cells, before and now; natural noise has some too, so only a clear rise counts, and a compressor or levelling that raises the pauses also raises it. Look at them with view_spectrogram (variants), and ask the user to listen before you recommend one.

analyze_tape

Analyze old tape recordings: per channel noise floor, signal-to-noise and bandwidth, correlation and time offset between channels with a recommended channel choice; mains hum (exact frequency); tape speed from the hum (when the hum is clear); clicks per minute; bandwidth; noise floor; voice pitch; and whether wow/flutter can be corrected. Use the result to choose set_channel_mode, set_clip_speed and clean_audio options.

analyze_channels

Analyze the two channels of stereo recordings (noise, bandwidth, correlation, time offset) and recommend left, right, both or both aligned. Same channel part as analyze_tape.

set_channel_mode

Choose which channels of a stereo recording are heard (e.g. only the better channel of an old tape, or both mixed after correcting a head misalignment). Applies to all clips from the recording. Undoable.

set_clip_tempo

Change one clip's tempo, e.g. make a voice 7 % faster (speed 1.07), without changing the pitch (keep_pitch, default): the voice sounds the same, only faster or slower, made with time stretching in the program. The words in the transcript follow. With ripple (default) everything after the clip moves with it. Audio only (not video). One undo step. The answer says the length before and after.

set_clip_speed

Set the playback speed of a recording (varispeed, the pitch follows like tape), e.g. to correct a tape that ran too fast or slow. To make a voice faster or slower without changing its pitch, use set_clip_tempo. analyze_tape gives the speed from the mains hum when possible. All clips from the recording follow and keep their order. Undoable.

measure_pitch

Measure the voice pitch (fundamental frequency) in a time range as it sounds now (with any speed change): median and spread in Hz.

level_to_target

Even out the level: measure every sentence (after plugins; without a transcript, speech parts found by loudness) and set level points on the clips so each sentence reaches the target loudness, with 50 ms smooth transitions in the pauses. In a story (indslag) the default is gentler: one level per clip (per person and recording), at most 4 dB from the others, because levelling sentence by sentence lifts the traffic or wind noise between sentences; but sentences in the same clip that lie more than 6 dB apart (e.g. one person close to the microphone and one further away) are levelled separately (at most 12 dB), with the transition at the quietest place between them, never inside a word. Single loud words that the limiter would otherwise take more than about 3 dB off at export are lowered, and sounds without words in the pauses (cough, knock, laughter) are kept below the speech peaks instead of getting the sentence's lift; the answer names them (and says whether find_noises finds them). Sentence by sentence, a person who as a whole lies far from the others (e.g. far from the microphone) is levelled from their own middle, a few much louder words at the start or end of a sentence (the other person's reply beginning) are levelled on their own, and in the pauses the lift is held down at the common lift (soft transitions; not in pauses with clear sound in them) so the room noise does not follow a weak speaker up and down. A level point gives at most +30 dB in total: when the weakest pieces need more, everything else is lowered instead (at most 12 dB; the export lifts it all to the target again). The answer says which sentences still could not reach the target and why (too weak even so, max_gain_db with the value that would fix them, or loud words lowered for the limiter); it never repeats advice that cannot change anything. Small clips without words between spoken clips (laughter, the rest of a pause) follow their neighbours' level. The answer gives the common lift and how much each piece is changed on top of it, consistently. Only the speech tracks are levelled: B-roll, music, the place's own sound and other follow tracks are never touched (they stay low under the speech), nor are other clips without words on the speech track. Running it again replaces its own earlier level points (measured afresh without them, so the same call gives the same result); level points set by hand are kept and built on, and the answer says so. One undo step.

get_waveform

Get the energy curve of a time range: RMS level in dBFS per point (default 200 points, at most 2000), and quiet places (start, end, quietest point, level), e.g. pauses between words where a cut is clean.

add_marker

Put a note marker on the timeline (shown in amber in the ruler; the note appears when the user points at it). Undoable.

remove_marker

Remove a marker (a note or a mark from an earlier automatic edit). Undoable.

list_markers

List all markers in time order: id, seconds, kind (note, or filler/pause/repetition/cut/cleaning/click/dropout for automatic edits), the note or label, and who made it.

redo

Redo the last undone change.

correct_word

Correct a misheard word in the transcript (e.g. a name), or hide it with empty text. Only the text changes, not the audio (a hidden word is still heard). Undoable. Point at the word with word_id from get_transcript (e.g. "3.136"; it stays the same when other words are hidden or corrected) or with word_index (the "i" number, which moves when a word before it is hidden), and always give word: the word as you read it. If the word there now is another one, nothing is changed and the answer says where the word is now. Re-read get_transcript after transcribe_range: ids and numbers in that range change.

fix_text

Correct the transcript text in a range: insert missing words, remove invented ones or change them, in one undo step (the audio is unchanged). A pure spelling fix (the same number of words, e.g. 'skolen' -> 'skolens') keeps every word's time; otherwise only the words that are new get new times, so sentences and subtitles do not move. Use it when transcribe_range keeps losing or inventing words, or a word is missing and cannot be added with correct_word. Give the range with from_word_id/to_word_id (ids from get_transcript; the words from the first through the last are replaced) or with start_seconds/end_seconds on the timeline, and text: exactly what is said there. The new words get times from the audio (the speech model listens with the correct text, the rest is spread by syllables over the speech), so cuts, read_story_script and subtitles use the corrected text. Word ids after the range in that recording change when the number of words changes: read get_transcript again before you correct or cut by id.

list_subtitles

Proofread the subtitles: every subtitle as it reads in the picture and in the SRT file (number, timeline seconds, text), also when burned-in subtitles are off. Read them all before a story is done and correct wrong words with fix_subtitle (punctuation such as double full stops is cleaned automatically).

fix_subtitle

Correct one subtitle (number from list_subtitles): give the text as it should read. The words are corrected in the transcript for that stretch (one undo step; the audio is unchanged), so the subtitle, the SRT file, the transcript and later cuts all use it. Fillers that subtitles leave out are kept. Line breaks are made by the program.

rename_speaker

Rename a speaker (e.g. "Taler 1" becomes the host's name). Speakers are numbered as the user sees them: "Taler 1" is 1 (also after renaming; same numbers as merge_speakers and split_speaker). Give source (file name such as "interview_2") when several recordings are transcribed. A voice the program recognises in several recordings (e.g. the journalist) has the same number in all of them, and the new name is used in all of them; the answer says where. One undo step.

export_audio

Export the timeline (or a time range) to a WAV file (24 bit, 48 kHz) or an MP3 file (44.1 kHz CBR, 128 kbit/s stereo / 96 mono by default, with ID3 tags) with podcast loudness (-16 LUFS stereo / -19 LUFS mono, peaks below -1 dBTP). With transcript: true the transcript is written next to it as .vtt and .srt (for Spotify and Apple Podcasts), so MP3 to Spotify with transcript is one step. Waits at most 20 seconds; long exports continue in the background and answer with a job id for export_status.

export_video

Export the edited video as an MP4 file (needs the Studio license): the picture from the original recordings following the cuts and camera switches, graphics and burned-in subtitles, and the finished sound at video loudness (-14 LUFS as YouTube and Spotify want, peaks below -1 dBTP). Short clips: give start_seconds/end_seconds and aspect 9:16 (vertical, the crop follows the faces). Starts in the background and answers with a job id; follow it with export_status. If a file already exists at path it is overwritten, and the answer says so (overwrites). warnings says what to fix before the video is done, e.g. a story without subtitles or a picture that blinks.

sync_cameras

Synchronise the cameras (tracks with video) and the separate microphones (audio files without video, e.g. one file per person) by their sound, like clapping on set: the reference camera stays, the others are moved so the same moment lines up. Cameras that lie after each other on one track are first given a track each, so it always works however they were imported. Audio files that share sound with the cameras become the speech (microphones; the cameras' own sound is muted); other audio such as music is not moved and follows the speech. Unsure results (the recordings do not share sound) are not moved. Needs Studio. Do this before editing.

cut_to_speaker

Multi-camera edit like a skilled editor: cut automatically to whoever is speaking, from the transcript's speakers. Replaces all camera switches (one undo step); they are shown as clips on the picture track. Rules: the picture follows the new voice 0.3 s later by default (a J-cut of 6-12 frames; picture_offset_seconds changes it, negative = before); never a shot shorter than the style allows and never the same camera twice in a row; short answers like 'ja', 'mm', 'præcis' do not cut; when they talk at the same time or change topic the wide angle (or without one both side by side) for 5-10 s; after 15-30 s on one speaker a 2-3 s reaction shot of the listener (preferably on their 'mm'), with three cameras alternating with the wide angle; with a wide angle it opens on it. The wide angle is found by itself on the faces (most faces, or the smallest = widest framing) when wide_track_id is left out, and the answer says why. Where the speech was cut (shortened pauses, removed fillers) the jump in the picture is hidden by a camera switch, so run it after tightening the speech. Afterwards the picture is checked and fixed by itself: a camera without picture, the same camera twice, too short shots, jumps still seen. The answer explains every shot (why), gives the style, numbers (switches, shortest, average, longest shot) and what the check found. Styles: rolig, interview (default), energisk. Needs a transcript and at least two cameras (sync_cameras first).

switch_camera

Switch camera from a time: from at_seconds the given camera (track id) is shown until the next camera switch. With split_track_id both cameras are shown side by side (split screen; each fills its half, cropped around the face). With until_seconds only until then (the picture goes back to what was shown there). One undo step. Needs Studio.

add_graphic

Add a graphic on the picture (needs Studio): a name tag (name and title, lower left), a chapter sign (upper left) or a full-screen title over the picture (darkened). For an intro or outro with its own piece of video and a background instead, use add_title_card. Graphics follow cuts like the picture. They are drawn locally in the graphic style (set_graphic_style).

add_end_card

An end slate (needs Studio): over the last seconds of the video the picture darkens and the sender is shown as text in the graphic style's look (e.g. the medium's web address), with an optional line under it and the graphic package's own logo above it if there is one (the corner logo steps aside). It fades in over the picture; nothing moves on the timeline. Replaces an earlier end slate. One undo step. Look at it with view_frames at the end.

add_name_tags

Name tags automatically: one for each named speaker the first time they speak for at least 2 seconds (up to 5 s on screen, kept clear of B-roll so the person is seen; re-run after cover_cuts if one is under B-roll). Rename speakers first (rename_speaker), and give titles per name. Name tags do not replace subtitles: a story for web or social media also needs burned-in subtitles (apply_graphic_package with subtitles: true), and the answer says so when they are missing. Needs a transcript and Studio.

set_graphic_style

Set this project's graphic style for all graphics (needs Studio): the look (avis, ren, nyhed, dokumentar), accent and text colour, font, a logo in a corner during the whole video, subtitles burned in from the transcript, their size (small, normal, large) and background (look, none, shadow, box). Only the given fields change. It changes only this project; the user's saved graphic package changes only with remember: true (when the user asks for it).

set_vertical_crop

Move the crop in vertical 9:16 (and square 1:1) by hand. By itself the crop follows the face continuously inside each clip (measured every half second, smooth, a little ahead) and avoids cutting readable text in the picture (signs) in half when it can. Set it by hand when that is not what you want: the clip shown at at_seconds (or only from_seconds-to_seconds, also across clips; it glides in and out) gets the crop left, center, right, an exact percent of the width, or moved from where it is; "auto" follows the faces again. A sign or text too wide for 9:16 (e.g. an arch with the place's name) cannot be shown whole: use "slide" (left to right) or "slide_left" so the crop glides smoothly across it over the clip or from_seconds-to_seconds (at least 1 s). Works the same on B-roll. The same crop is used by Send ud, view_frames with aspect 9:16 and the preview in Grafik. One undo step. Check it afterwards with view_frames aspect 9:16 at the same times.

graphics_status

What graphics there are and what is missing: the user's saved graphic package (look, logo and whether the file exists, corner, colours, font, subtitles, transition), the project's own style and whether it is the package, every name tag (and whether it is under B-roll), other graphics, speakers on the timeline without a name tag, and the burned-in subtitles (count, longest on screen, longest line). Call it before graphics in a story (indslag) and after, then look with view_frames.

apply_graphic_package

Use the user's saved graphic package (look, logo in its corner, colours, font, transition) on this project, one undo step (needs Studio). Without a saved package the program's default look (avis) is used, and the answer says so: tell the user. A story (indslag) for web or social media, e.g. for a news site, has burned-in subtitles because many watch without sound: pass subtitles: true unless the user said no (without it the package's own choice is kept, and the default package has none; the answer says when a story has no subtitles). look overrides the package's look. Afterwards: add_name_tags, then view_frames at a name tag and a subtitle to check it.

remove_graphic

Remove graphics by id (ids from get_project). A title card is removed together with its own piece of the timeline (everything after moves back).

add_title_card

Add a title card (needs Studio): its own piece of video with no recording behind it, only a background with a title and subtitle, e.g. before the start or after the end. Everything after it moves later (one undo step), so the sound is silent there; put music from the library under it if wanted (place_jingle). Backgrounds: one colour, a gradient of two colours with an angle, an image (cover, center or blur, e.g. the logo in the middle with use_logo) and an optional faint pattern. Drawn locally in the graphic style's font and colours. Remove with remove_graphic.

edit_title_card

Change a title card's title, subtitle, background or length (a new length moves everything after it).

set_transition

Transitions in the picture (needs Studio): "cut" (hard cut, as before), "crossfade" (the pictures blend into each other) or "dip" (via black), with a length (default 0.5 s). For the whole project it is used where the picture changes to another recording (e.g. the next clip in a story or B-roll) and at title cards; jumps within the same recording (removed words) and camera switches stay hard cuts. With clip_id only that clip's start gets it (also within the same recording); kind "project" removes the clip's own transition. Shown in the player, the MP4 and in Final Cut/Premiere (export_for_editors: Cross Dissolve and Fade To Color / Dip to Color).

set_audio_crossfade

Set the length of the AUDIO crossfade at one cut in the speech (the cut nearest at_seconds on the speech tracks, at most 0.5 s away; e.g. the start of a clip). By default a cut in speech gets up to 0.1 s, made only of the silence in the recordings at the cut. seconds: the whole crossfade (half before, half after the cut), up to 2; 0 = hard cut (only 3 ms soft edges); leave out to go back to the default. It is still made only of silence from the recording (never into words), so it can be shorter than asked: the answer says how long it became. One undo step.

lengthen_pause

Make the pause at one cut in the speech a little longer (e.g. 'air before the last bite'): the cut nearest at_seconds on the speech tracks (at most 0.5 s away), seconds longer (e.g. 0.3-1). Only silence from the recordings is used: the clip before continues into the silence after it, and the clip after starts earlier in the silence before it (never into words, no artificial silence); the answer says how much there was. Everything after moves on all tracks; B-roll, the place's sound, music and room tone that run across the cut are extended. One undo step.

analyze_footage

Footage analysis on this Mac (needs Studio): finds shot changes with faces and camera tilt (Apple Vision) and describes each shot with a local vision model (framing, people, what, where, readable text, usable or not). Pictures never leave the Mac; only the text descriptions are available here. Videos filmed upside down or lying down (the phone stored a wrong rotation) are turned first, so the pictures are described standing up. If there is not enough free memory for the chosen vision model right now, a lighter installed model is used and footage_status says so; the background queue retries by itself when memory is short. Runs in the background; results are stored in the project and reused (shots already described are not described again unless a model is given). Follow with footage_status, then search_footage; contact_sheet shows all recordings at once.

footage_status

Progress of the footage analysis: running, what it is doing, progress 0-1, shots and described shots in total (including descriptions reused from an earlier analysis; when nothing is running, the numbers stored in the project), describedNow (described in this run), seconds per image and any error. videos / videosAnalyzed say how many videos in the project are analysed, and copiesWaiting how many working copies are still being made (the videos are still loading); when nothing runs, the label only says Færdig when every video is analysed and loaded, otherwise it says what is missing. queue says whether the background queue is running it, waiting for the transcription, or failed (and retries); turned lists videos that lay down or stood upside down and were turned; note says when a lighter vision model was used because memory was short.

search_footage

Search the shot descriptions from analyze_footage (e.g. to find B-roll that fits what is said). Returns each shot's source, time in the file (sourceSeconds), where it is on the timeline (if used), framing, people, faces, description, readable text and whether it is usable. Text only; pictures stay on the Mac.

place_broll

Place one piece of B-roll by hand: a piece of a video (e.g. a shot found with search_footage) is shown over the cameras at a time, on the B-roll track (created if missing). Sound: the B-roll's own sound low under the speech ('place', default in a news story; the track is ducked under speech), 'full' or 'off'. A portrait video in a wide story is checked (Vision counts people, faces and text as is and turned a quarter): if the phone stored a wrong rotation so the picture lies down, the video is turned so it stands up, and the answer says so; otherwise the answer WARNS that it is portrait (shown narrow with black sides) or that the camera was held sideways - then choose another shot. One undo step. Needs Studio. To cover jump cuts, prefer cover_cuts; to swap a piece's picture, replace_broll.

replace_broll

Swap the picture of one piece of B-roll that is on the timeline (laid by cover_cuts or place_broll) without planning again: same time, length, level and fades, another piece of video (e.g. an alternative from cover_cuts or a shot from search_footage). The piece is found by a timeline second inside it. If the new picture has speech, its sound is muted. Warns about portrait or sideways pictures. One undo step. Needs Studio.

edit_broll

Change one piece of B-roll that is on the timeline (laid by cover_cuts or place_broll), found by a timeline second inside it: trim it (start_seconds/end_seconds on the timeline), choose another place in the same recording (source_seconds, seconds in the file; e.g. a calm stretch seen with view_frames source_id), and/or move the whole piece (move_to_seconds, same length). Level, fades and sound stay. Refused if it would overlap another B-roll piece or run past the end of the recording. One undo step. The answer gives before and now on the timeline and in the file, the shot descriptions seen and what the camera does. Look at it afterwards with view_frames.

nudge_clip

Nudge one clip a little later or earlier on its own track, frame by frame (frames, at the timeline's frame rate) or by seconds: e.g. move a B-roll piece 2 frames so the picture changes on a word or a movement, or a name tag clip. Find it by a timeline second inside it (B-roll before other tracks) or clip_id; track limits the search. Length, picture, level and fades stay. Refused if it would start before 0 or overlap another clip on the track. One undo step. The user can do the same in the timeline: select a clip and press , (one frame earlier) or . (one frame later), with shift 10 frames.

cover_cuts

Lay B-roll over a news story like an editor (needs Studio and analyze_footage), in one plan: (1) the visible jump cuts inside the same recording (and with include_changes: true the changes between recordings, never the first time a person is seen), from about 1 s before to 2.5 s after the cut; (2) with illustrate (default on) shots of what is being said, where the speech names something the shot descriptions show (e.g. 'kuttere, fiskehal og røgeri' over the boats, the hall and the smokehouse; an enumeration gets 2-3 shots in a row), and if still short, mood shots of the place over stretches of one face (also shorter ones, with at least 2 s of face around or in a row with another piece); until the coverage target (coverage, default 0.4 of the story; 0.35-0.45 for a web story; the plan is laid again until the finished pieces reach it, as far as the rules allow). Every piece is 3-6 s and at most 9 s of B-roll in a row (then the speaker is seen again); never in the first and last 3 s (except an establishing wide shot of the place when the story opens on speech, see opening), never in the first 4 s a person is actually seen (a face or a person in the picture, not just the start of the clip), never over name tags or title cards; speech over a picture without any person (e.g. a wall or the ground while someone talks) is a voice the viewer cannot place, so it is ALWAYS covered completely (kind 'stemme', pieces in a row, also in the first seconds); pieces touch or leave at least 2 s of face between them; never the same shot or the same part of a recording twice. The sentence said over most of a piece counts most (a word from a sentence that only touches the piece counts less), and the establishing shot prefers what the story is about. Broad words (young, people, new) never choose a shot alone, and a proper name must be in what the shot shows (not a name that only looks alike); neutral shots are wide shots of the place, not details. Shots are chosen from the shot descriptions by the words (not by readable text, which the vision model may invent), skipping unusable, tilted and portrait shots, stretches where the camera pans or turns (never a clear pan) and the interview recordings; an interviewee (recognised by the face, or 'maybe' by the clothes when the face is not recognisable) is only shown while that person's own recording is under the piece; cheerful shots are avoided over serious speech; the place's own sound is laid low under the speech (ducked). One undo step. Running it again REPLACES the pieces an earlier cover_cuts laid (B-roll placed by hand with place_broll stays). ALWAYS run with preview: true first, read each piece's kind, 'said', 'illustrates' and the chosen shot, and check that it fits and the mood is right (no festive market-day shot over a story about a fire); change pieces with choices (another shot from 'alternatives' or search_footage, or skip) and run again without preview. To swap the picture of one piece that is already on the timeline, without planning again, use replace_broll. Answers: pieces by kind, jump cuts and changes covered, coverage in seconds and share, skipped and why. Every piece has the same fields, also without a picture (hasShot false; shot has an empty file and why says why).

set_track_role

Set a track's role in the sound bed: 'speech' (its speech ducks the followers), 'follow' (lowered automatically under speech while playing and exporting, so it follows when the speech is re-cut: music, B-roll sound, sound of the place) or 'none' (as before). Without any speech track, the ordinary transcribed tracks count as speech. A follower's depth comes from the measured loudness unless duck_db is given (ChatCut-like: down 120 ms before speech, up over 350 ms, pauses under 0.8 s stay down). duck_under_speech is the old way: it bakes fixed level points into the clips. Undoable.

add_music_bed

Lay a music bed under the whole news story on a 'Musik' track: from start_seconds (default 0) to the end of the story, fade in and out (1.5 s and 2 s), repeated with 1.5 s overlap and crossfade if too short. The level is set from the measured loudness (about 6 LU under the speech without speech) and the track is ducked under the speech (about 16 LU under while someone speaks). Only the user's own or royalty-free music (from the sound library or a file), or music made with the user's own ElevenLabs account (elevenlabs_music, which can also lay the bed itself); never music from elsewhere. One undo step. Answers the measured numbers.

add_room_tone

Sound of the place (lyd fra stedet): find a stretch of the B-roll recordings' own sound without speech (no words in the transcript, little voiced sound, steady, no sudden sounds) and lay it low under the whole story on a 'Lyd fra stedet' track, so the background does not jump at the cuts between recordings: the steadiest stretches (at least 3 s, up to 30 s each) from several recordings one after the other with 1 s crossfades, each matched to the first one's level, and repeated only if they do not reach the end. level_lu (default 20) is how far under the speech it lies while someone speaks; in the pauses it is 3 LU higher. It follows the end of the story when the story gets longer or shorter. Shows no picture. preview: true only finds and reports the stretch. One undo step.

elevenlabs_status

Is the user's own ElevenLabs account added (for music, sound effects and speak), and how much of the period's credits are used. The key is never shown.

elevenlabs_voices

List the voices for speak (elevenlabs_speak) on the user's ElevenLabs account: the user's own and saved voices first, then a few of ElevenLabs' standard voices, with id, name, kind (egen/standard) and description. Needs the user's ElevenLabs account (Settings, Tjenester).

elevenlabs_music

Make music with the user's own ElevenLabs account from a description and a length (instrumental by default) and put it in the sound library (kind music, intro, outro or jingle), so the project works offline afterwards. With bed: true it is also laid as a music bed under the whole project at once (like add_music_bed: fades, repeated with crossfade, ducked under the speech; one undo step). For an intro or outro: kind intro/outro, then place_jingle start/end. Paid ElevenLabs plans only; the user pays ElevenLabs and their terms decide commercial use. Answers the credits used. Without an account it says so: then there is no generated music.

elevenlabs_sound_effect

Make a sound effect with the user's own ElevenLabs account from a description (and a length, 0.5-30 s) and put it in the sound library (kind effect). With at_seconds it is also put on the 'Lydeffekter' follower track at that time (level about 3 dB under the speech, ducked a little under speech; one undo step, visible on the timeline). Answers the credits used. Without an account it says so.

elevenlabs_speak

Speak (voiceover): read a text aloud with a voice from the user's ElevenLabs account (elevenlabs_voices; Danish works) and put it in the sound library and on its own 'Speak' track at a time (default after the end of the timeline). The text comes with from ElevenLabs' timing, so it is in the transcript/manuscript at once (otherwise it is transcribed locally). Give speaker (the person's name) when the voice speaks for someone, so the speaker in the transcript has that name and not the voice's. To make a voice more lively: lower stability (e.g. 0.3) and some style (e.g. 0.3-0.5); speed 0.7-1.2 (made by the voice, the pitch stays; for an existing clip use set_clip_tempo). With model eleven_v3, sound tags in square brackets (in English, e.g. [excited] or [whispers]) steer the delivery; they are never in the transcript or subtitles. A name the voice says wrong: pronunciations with the word and say, an ordinary Danish spelling of the sound (works best; hyphens or doubled vowels did not help; only the voice gets it, the text keeps the right spelling). Level matched to the speech. One undo step, visible on the timeline. Answers the characters and credits used. Without an account it says so.

elevenlabs_voice_change

Voice change of recorded speech (ElevenLabs speech to speech, with the user's own ElevenLabs account): keeps exactly the delivery of a recording (tone, timing, pauses, emphasis) and gives it another voice from the user's ElevenLabs library. Use it when a recording has the right delivery but the wrong voice (e.g. a caricatured or strained voice); use elevenlabs_speak when there is no recording. Choose what: speaker (all their words, optionally between from_seconds and to_seconds), clip_id, or track with from_seconds and to_seconds. Start with preview: true (only the first 5-10 s, into the sound library, nothing on the timeline; answers the credits used and the estimated cost of the whole job), let the user listen and choose the voice, then run it without preview. The sound is sent in pieces of at most 4 minutes, split in pauses (never inside a word); the new voice replaces the old on the same track at the same times with the same length, so everything else fits, and the transcript and the speaker's name stay. One undo step; the original sound stays in the project. Costs about 1,000 ElevenLabs credits per minute of sound. Only voices from the user's library; never to copy a real person's voice.

import_clips

Import several video clips one after another on one track (sorted by recording time, otherwise by file name), e.g. all the clips for a news story (indslag). Cameras filmed at the same time (recording times overlap, or the names say camera) are instead put on a track each from 0; then run sync_cameras. Needs Studio. Answers the track and each clip's place on the timeline. Transcription and then footage analysis start by themselves in a background queue (one at a time, retried after an error); follow them with get_project (transcription, footage) and footage_status instead of starting them yourself. With transcribe false (or the user's setting off) the clips are not transcribed until you call transcribe. Then read_story_script and apply_story_script.

arrange_story

Reorder an edit by timeline seconds (e.g. pieces without speech): give the pieces to keep as timeline seconds on the current timeline, in the order they should play; they are laid one after another from 0 on that track (one undo step). For speech in a news story (indslag) or interview use read_story_script and apply_story_script instead: they cut by sentences and never inside a word. Here every boundary in speech is moved to the nearest pause between words (at most 0.5 s; the answer says what moved), a boundary in speech without a pause nearby is refused, and the answer ends with the cut check. Afterwards: place_broll over the jump cuts (timeline positions change after this), add_name_tags, add_graphic, export_video.

read_story_script

Read ALL spoken material for cutting by text (news story/indslag, interview, short versions): every transcribed recording, also those not on the timeline, as sentences with short numbers like [M1.3] (speaker initial, recording 1, sentence 3; only the two numbers count) and their length in seconds, followed by the current timeline as the same kind of lines (words not heard are struck through with ~~ ~~). Each recording's heading lists its speakers with the numbers rename_speaker and merge_speakers use ("Karen = Taler 2"). The sentence numbers stay the same until the text of a recording changes (correct_word, transcribe_range, merge_speakers): read it again after such a change. Use this, not timings from get_transcript, whenever you choose or cut speech. Then cut with apply_story_script. Never show the numbers to the user; quote the words.

apply_story_script

Cut speech by text. Use this for ALL cutting of speech in a news story (indslag), interview or short version; never compute seconds for speech yourself. script: one line per sentence in playing order. '[M1.3]' plays the whole sentence. '[M1.3] text with ~~struck words~~' removes the struck words (copy the line from read_story_script and strike; never change, add or respell words; case, punctuation and spaces at word boundaries do not matter). A contiguous part of a sentence written alone plays only that part. Consecutive sentences from the same recording play as recorded (pauses over 1 s are tightened). Changed or ambiguous words reject the whole script with a Danish explanation per line. The editor finds the words and puts each cut in the silence before the first and after the last word (found in the sound). A cut never goes into a word that is not to be heard (struck, hidden with correct_word, or from another sentence), so such a word never reaches the text or the subtitles. The pause at each cut is about pause_seconds (default 0.3, speaker changes 0.5), using only silence that exists in the recording (no digital silence is invented). Where a speaker change has almost no silence in the recording (common outdoors), the missing pause (at most 0.45 s) is made of the place's own room tone from the same recording (on the follow track 'Rumtone ved skift', faded softly in and out) over a silent moment of picture of the new speaker listening just before they speak (or the previous speaker after their last word), never showing a person's own lips moving; the answer lists the pause at every speaker change; room_tone_pauses: false turns it off. The last piece ends with natural air after the last word (the silence after it in the recording, up to 0.8 s; without silence 0.3 s; never into the next word); fade_out_end adds a fade to black. Before anything changes (also with preview), every cut is listened to with the local speech model and repaired: a missing, cut-off or extra word (e.g. 'øhm' or a stump of the removed words) moves that boundary (at most 3 times, guided by a short pass of the recording itself, never into a word that is not to be heard), and the answer says what was moved. Then the result is listened to once more as it lies (with the pauses), exactly as check_cuts does, and the answer ends with that cut check: check_cuts right after gives the same verdict for the same cuts. Takes a few seconds per cut. preview: true shows the result (the bites as heard, total length and the cut check) WITHOUT changing anything and shows the user a 'Forslag til indslag' card with a 'Klip det' button: use it for a new story and wait for the user's ok unless they asked you to just do it. Without preview: rebuilds the speech track as one undo step ('Klip efter teksten'); the picture follows, other camera tracks follow. With several cameras and a microphone per person, every bite is cut for the same time on ALL microphones and cameras and moved together, so sound and picture stay together (also in a cold open, a new order and where two people talk at once), and the camera switches are made again for the new order with the cut_to_speaker rules (style interview; the answer says who is on which camera; run cut_to_speaker afterwards for another style). B-roll follows the speech it lay over (pieces whose speech is gone are removed; the answer says which). Each clip keeps the level and Jævnt niveau points of the place its sound came from (never from a silent picture); new pieces have none, and the answer says so: run level_to_target again. After the cut the speech is measured as it plays, and the answer starts with ADVARSEL if a bite with words is almost silent or a sentence lies more than 6 dB from the other speech (it says which and which way). Fix doubtful cuts (TVIVLSOMT) and run again.

check_cuts

Check every cut on the speech track(s): the last and first words around each cut, whether the sentence before ends (full stop or question mark), the pause before and after in ms (silence in the sound), the sound level right at the cut relative to speech (dB), whether the boundary is in or at a word, speaker change, and jump cuts in the same recording (to cover with B-roll), plus the total length against target_seconds. It also listens to every cut with the local speech model (a few seconds per cut) and marks a cut TVIVLSOMT when a word is missing, cut off or extra ('hørt: ...'). It moves nothing: cut again with apply_story_script, which repairs the boundaries. A fault counts only when the speech model hears it in at least two of three windows around the cut, and the verdict is remembered by the sound around the cut: the same cut gets the same verdict every time (also after apply_story_script, a level change elsewhere or a new check). A word that is missing but has no sound in the recording is not a fault of the cut (the note says the text is probably wrong: fix it with fix_text); it never advises adding a word where nothing is said. When a boundary was moved by apply_story_script and something is still heard wrong on the same side, it is one piece of advice, not two. STRAMT (sound or no pause at the boundary, but clearly under the speech) is usually fine. Doubtful cuts are shown to the user with Lyt buttons. Only sound that is actually played is heard (a clip played below -40 dB counts as silence), and the answer starts with ADVARSEL when a bite with words is almost silent or lies more than 6 dB from the others (measured as it plays); never export before that is fixed. Run it after every change to speech and fix the doubtful cuts before you say the edit is done.

export_for_editors

Hand the edit on to Final Cut Pro, Premiere Pro or DaVinci Resolve (needs Studio): writes <name>.fcpxml (Final Cut, DaVinci), <name>.xml (Premiere, DaVinci), the finished sound as a WAV (-16 LUFS) and cleaned audio files. The cut picture with camera switches is on V1 with the transitions (Cross Dissolve, Fade To Color / Dip to Color) and the title cards as their own video files (<name> titelkort N.mp4, drawn with their background), B-roll on V2, other graphics as titles (Final Cut) or markers (Premiere), the finished sound on A1 and the original audio tracks below (switched off).

start_export

Start exporting to a WAV or MP3 file in the background and answer at once with a job id. Same options as export_audio. Follow it with export_status.

export_status

Progress of an export started with start_export or export_audio: progress 0-1, done, error and the loudness report.

tell_user

Show the user one short status line in the Producer panel, where every step you take is already listed in plain Danish. Use it in bigger tasks: before each larger part (e.g. "Nu laver jeg jinglerne", "Nu klipper jeg indslaget ned til to minutter") and, with done: true, once when everything is finished (say what is ready and where, e.g. "Færdig: afsnit 12.mp3 ligger på skrivebordet"). Not needed for single small edits.

check_work

The check before you say you are done (always run it after a larger task, and again after you have fixed something): black picture, two microphones open at the same time (double sound), different loudness between the people, cleaning that damaged the voice, several cameras without any switch, the measured after-check of the result (hard cuts, holes, level jumps at cuts, start and end, as check_result), the editor's tempo notes (dead air, repetitions, fillers, weak start, abrupt end, as critique_edit), and what the listening model hears at the start of the speech (three neutral questions per kind of fault, now and before; only 2 of 3 counts). Fix every problem it finds yourself, run it again, and only say you are done when it finds nothing; never ask the user to check something this check can find.

request_tool

Ask for a tool you are missing (the program is being tested). Whenever a task needs something no tool can do, or a tool does it badly or gives you misleading answers, call this instead of giving up or asking the user to do it by hand: it shows a green box in the chat and is saved for the developers. Then continue with the closest way you have, and say in one sentence what is missing.

check_result

The after-check of the FINISHED result (run it after every export and every larger change, before you say you are done): measures the sound 1.5 s on each side of every cut in the speech, plus the first and last 2 s, and the loudness as ebur128 (integrated LUFS, true peak, loudness range). Finds hard cuts in the middle of sound (a click), cuts that lie in sound without a pause (a word may be cut off), holes of digital silence, speech that jumps in level after a cut, dead air at a cut, no air before the first word or a long silence at the start, an abrupt end or a long silence at the end, and loudness off target. With fix (default) it repairs what it can itself, at most 3 rounds (a short fade at a hard cut, closing a hole, levelling the speech after a jump), and checks the timeline again after each round; after fixes, export again. Everything here is MEASURED, not heard: say so, and use check_cuts for cut-off words and judge_listen to hear.

critique_edit

The editor's critique of the finished edit, as a listener experiences it, not just technique (agents tend to cut too little and stop too early): dead air between words, answers that run too long, repeated words and restarts, fillers, a weak start (late first word, or starting with fillers), an abrupt end (mid-sentence or no air), whether too little has been cut, and the tempo (words per minute, share of pauses, longest pause, fillers per minute). Each note has a time and a concrete fix with a tool. Rules on the words as they play (no model, no cost), so the same edit always gets the same verdict. Run it after cutting and before you say you are done; act on the notes yourself (a meeting is only checked for long silence) and run it again.

judge_listen

A careful, honest listening verdict on an excerpt (use it instead of listen when you must decide whether something is wrong): measurements (level per speaker, noise in pauses, the listening test score, clicks, holes and level jumps at the cuts in the excerpt) combined with the local listening model asked several questions per place, each on its own at the same loudness (the model cannot compare two clips in one question: it answers 'B' most of the time). A fault counts as heard only when at least 2 of 3 questions say so; with compare_before (default) the same questions are asked of the sound before cleaning, so a fault heard in both lies in the recording itself. The answer separates what is MEASURED, what is HEARD (with how sure), and what is only numbers; say it that way to the user. Measured on 8 excerpts with known faults (30/10): asked one yes/no question the model missed 7 of 8 hard cuts and all 8 level drops; at a cut it mostly hears holes (on new material 8 of 32 faults at cuts: holes 6 of 8, clicks and level drops 0) and cannot say what is wrong, so at a cut its yes only counts together with a measured fault (otherwise it is listed as unsure). For the sound itself only reverb is heard reliably (6 of 8, never on clean); noise, cleaning artifacts and distortion are judged by the measurements. Takes 1-2 minutes per 30 s.

suggest_cold_open

Suggestions for the cold open of a story: the strongest whole quotes (1-3 sentences from one person, best 5-10 s) with feeling, conflict or a surprise, never a question, an unfinished sentence or the person asking behind the camera. Each has the sentence numbers from read_story_script, the length and why. Choose the one that fits the angle, put it first in the script for apply_story_script, and tell the user in one sentence why you chose it. Then add_story_intro. Works the same with several cameras and a microphone per person (the cameras follow each bite).

add_story_intro

The intro after the cold open in a story (video): makes room between two whole sentences (after the first bite, or after_text/after_seconds), puts the jingle there (or the place's own sound, 3-8 s), lays a calm, wide shot under it (from the picture descriptions: wide, no faces close up, a sign with the place's name is preferred; with several cameras and no descriptions a calm camera shot where nobody in the picture speaks: a person listening or the wide shot) and the title over it. Never a black picture under the jingle. One undo step per part. Check it with view_frames afterwards (also 9:16).

check_story

The check of a finished story, as an editor would do it (run it before check_work and before you say the story is done): length against target_seconds, the opening (cold open 5-10 s, then title or jingle 3-8 s, picture under the jingle), pace (bites over 20 s, one person over 30 s in a row, the same picture over 15 s, long silences), repeats, whether the ending lands (a whole sentence, not a question, air and a fade after), B-roll (2-5 s, no panning) and name tags (over B-roll, or on the person asking behind the camera). With several cameras it reads the speech from the microphones; check_work checks the picture afterwards (a camera without picture, black picture, the same camera twice). Fix what it finds and run it again.

play

Play the timeline so the user can listen, optionally from a time.

pause

Pause playback.

show_plan

Show the user a short plan before a big task (a story/indslag, a whole podcast, several cameras): 3-5 steps in plain Danish and an estimated time. Then start at once; do not wait for an answer.

ask_user

Ask the user one short question with 2-4 answers as buttons, only when something is unclear that you cannot find out by listening, looking or reading (e.g. which microphone belongs to whom). After calling it, stop and wait: the answer comes as the user's next message.

report_problem

Offer the user to send a problem report to the developer, when the user says something does not work, or something went wrong that you cannot fix. The user sees the report (what they wanted, your last tool calls, errors, version and Mac; never audio, video or text from the recording) and must say yes before anything is sent.