Academy

Learn Peak by making something

Thirty-five courses across nine tracks. Each one says what you end up with, gives you the exact words to paste into Peak, and then explains why it worked. They are ordered so the one after teaches the reason for the one before: the deck course teaches you to ask for slides, the next teaches why the deck looks like a deck, and the one after takes it apart on a whiteboard.

Everything here is drawn from the documentation and the App Store release notes for 1.6.1. Nothing needs an account or a key unless a course says so.

Command

Summon the workspace and drive it.

Summon it, then feed the one input A single hotkey brings the workspace over whatever you were doing, and one input becomes five different things. Start here

You end up with: A lookup that becomes a note, a board, a whiteboard or a chat without a window change.

Control + 1Landing input14 search engines

Ask Peak this

Open Peak with ^1. In the landing input, type a question and leave the mode on Search. Now switch the mode to Note and type the same words — you get a block note titled with them instead of a results page. Then paste a URL into Search and watch it open the site instead of searching for it.

Step by step

  1. Press Control + 1 — Peak toggles over the top of whatever you are doing. Change it under Settings → General; Command, Shift, Option and Control combinations all work.
  2. Land on the Landing page. Pick one of five modes: Search, Note, Tasks, Whiteboard, LLM chat.
  3. Submit. Each mode opens as a tab, so a half-finished thought sits beside the page that prompted it.
  4. On macOS, put Peak in the menu bar and let it hide when it loses focus. It becomes a command surface rather than one more window competing for space.

Worth knowing

  • Nothing is required up front: no account, no API key, no network calls beyond the pages you visit. Everything in this catalogue works before you configure anything.
  • Fourteen engines sit behind the same field — DuckDuckGo, Google, Bing, Brave Search, Startpage, Wikipedia, Stack Overflow, GitHub, MDN Web Docs, Google Scholar, WolframAlpha, YouTube, Unsplash and IMDb. Changing the default changes the toolbar address field too, because both read one list.

Source: Peak Browser documentation

Two tabs, both alive Split the content area so a video keeps playing while you read beside it — and the arrangement comes back when you reopen Peak. 2 min

You end up with: A permanent two-up bench: reference on one side, the thing you are making on the other.

Show BesideClose SplitPane focus

Ask Peak this

Right-click a tab you are not on → Show Beside → Left or Right. Put a long video on one side and your notes on the other side, then quit Peak and reopen it — the split returns on the same sides. Click the other pane’s tab to move the address bar and toolbar across.

Step by step

  1. Right-click a tab you are not currently on. On iPad, press and hold instead.
  2. Choose Show Beside, then whether it goes on the left or the right.
  3. Both tabs stay live and both are highlighted in the strip, each marked with the half of the window it holds.
  4. Click the other pane’s tab to swap which pane the address bar and toolbar belong to. Each pane stays where it is on screen.
  5. Choose Close Split from the same menu to go back to one page.

Worth knowing

  • The arrangement survives quitting Peak — unlike the tab you happened to be on, which gives way to a fresh one at launch, because a split is something you chose rather than something you ended up with.
  • It is offered wherever there is room for it: every Mac, and iPad in landscape or split view. Recover a tab you closed by accident with Shift-Command-T.

Source: Peak Browser documentation · App Store release notes, v1.6.1

Profiles, incognito and saved sessions Keep work and personal browsing from bleeding into each other, and close a piece of research without losing it. 3 min

You end up with: A named workspace per context, plus a session you can reopen next month in one action.

ProfilesIncognitoSaved sessionsBookmarks

Ask Peak this

Make one profile per context. Save the tabs from a research session as a session, close them all, and reopen the session next week. Then open an incognito tab and confirm it never appears in your history.

Step by step

  1. Create a profile for each context. Cookies, sessions, caches and local web storage are isolated per profile, and each carries its own name, icon and colour.
  2. Use Incognito when nothing should persist — it skips history and activity persistence entirely.
  3. Save a set of tabs as a session and restore them together later.
  4. Use the dashboard for bookmarks, bookmark groups, sessions and jump-back entries for recent work.

Worth knowing

  • The Activity Hub is a timeline of recent searches, pages, notes, boards, chats and whiteboards — the way back to context without having to remember where you left it.
  • Pin the tabs you keep open all day so the strip stays honest about what is actually live.

Source: Peak Browser documentation

Capture

Turn a lookup into notes, boards and projects.

Block notes that hold structure Capture in blocks — headings, to-dos, code, tables — instead of one grey paragraph you will never reread. Start here

You end up with: A structured page: headings, claims as bullets, a real table of numbers with sources, and a to-do block per next action.

Note modeBlock typesTablesPDF export

Ask Peak this

Capture this page. Then: "Turn it into a block note: three headings, the key claims as bullets under each, a table of the numbers with a source column, a to-do block per next action, and a divider before the sources. Link the original page at the top."

Step by step

  1. Switch the landing input to Note, type a title or a first thought, and submit. The note opens as a tab.
  2. Capture a page rather than retyping it — the page becomes the note.
  3. Use the block types deliberately: headings, paragraphs, to-do, code, markdown, links, separators, images and tables.
  4. Drop images in by drag or through a file picker. On macOS, export the note to PDF.

Worth knowing

  • Never type Markdown markers into a native block. The block already carries the structure, so a "#" inside a heading shows up as a literal "#", and "1." in a numbered block becomes text rather than numbering.
  • Use a real table block for tabular data instead of a code fence. The columns resize, and it stays editable.
  • A note keeps the thinking; a board keeps the doing. When a note grows a column of "things to check", that column wants to be a board.

Source: Peak Browser documentation

A board from a research session Turn what you just read into lanes with cards you can drag, while the sources stay open beside it. 3 min

You end up with: A three-lane board where every card carries one claim and one next action.

Tasks modeLanesDrag and drop

Ask Peak this

Read three sources on one question, then: "Make a task board called <topic>. Lanes: To read, In progress, Shipped. One card per source with the claim it makes, and a separate card for each thing I should do next. Put anything I cannot verify yet in To read."

Step by step

  1. Switch the landing input to Tasks and name the board. It opens as a tab.
  2. Cards drag between lanes. Boards persist locally.
  3. Keep the source tabs open beside the board, or in the second pane, while you triage.
  4. Boards can take part in mesh sync when it is on, which is what makes them useful in a room rather than alone.

Worth knowing

  • A board beats a note for questions still open. The card is the unit of doubt, and a lane called "To read" is a promise you can see.
  • Name lanes after your process, not after a generic template. If nothing ever sits in a lane, delete the lane.

Source: Peak Browser documentation

Projects, and the library of everything Peak made Group the conversation, the site and the reference material so the next chat starts already briefed. 4 min

You end up with: A project whose instructions and files are picked up by every later conversation inside it.

ProjectsStanding instructionsReference filesLibrary

Ask Peak this

Create a project called <name>. Instructions: "Write for a technical reader, British spelling, never invent a source, and keep prose under three sentences per paragraph." Add the two PDFs I am working from as reference files. Then ask a question without re-explaining any of it.

Step by step

  1. Create the project and write standing instructions: audience, voice, and one hard rule.
  2. Attach the reference material the work depends on.
  3. Work inside the project. Each conversation starts knowing the instructions and the files.
  4. Everything Peak has made — sites, conversations, sessions, decks, notes — sits in one searchable library.

Worth knowing

  • Instructions are the cheapest quality upgrade available. Three lines about audience and voice remove most of the editing you would otherwise do afterwards.
  • A durable decision belongs in project memory so a later conversation does not have to be told again. Keep it to what will still matter next week.

Source: App Store release notes, v1.6.1 · Verified here — checked against this workspace

Think

Reason on an infinite canvas.

The whiteboard, properly An infinite canvas with real connectors, maps and icon assets — not a sketch pad you draw on once. 5 min

You end up with: One diagram that survives being rearranged: cards wired so the wires redraw when a card moves.

ConnectorsShapesLucide iconsMap assetsEmbeds

Ask Peak this

Open a whiteboard. Put the central idea in the middle as a card, then four consequences around it. Wire each one to the centre with its own line, then drag the outer cards about and watch the connectors follow instead of breaking.

Step by step

  1. Open a whiteboard from the landing input.
  2. Draw freehand, or use lines, arrows, elbow connectors and curved connectors.
  3. Shapes available: rectangle, circle, diamond, triangle, inverse triangle, cylinder.
  4. Add text, sticky notes and tables. Drop in images, documents, video, audio notes and live web embeds.
  5. Group elements and set layer order, then export a selection.
  6. Use the Lucide icon assets and the world, continent and country map assets.

Worth knowing

  • Each connector style has a different job. A straight line reads as structure, a curve reads as flow, an elbow reads as wiring. Mixing them at random is what makes a board look like a scribble.
  • There are tool shortcuts for select, pan, draw, text, sticky notes, shapes, arrows, grouping, duplication, zoom and delete. Learning four of them is the difference between a board you use and a board you avoid.
  • Start a board from the work rather than from nothing. An empty infinite canvas is a tax on thinking.

Source: Peak Browser documentation

Maps and icon assets on the canvas Put a real map on the board and pin the story to it, then let icons carry the legend. 3 min

You end up with: A country map with a sticky note for every place that matters and an arrow to what happens there.

World / continent / country mapsLucide iconsSticky notes

Ask Peak this

Add the country map of <country> to the board. Then a sticky note for each city in this list, sitting on the city, and an arrow from each note to a card that says what happens there. Use one Lucide icon per kind of event so the board reads without a key.

Step by step

  1. Add a map asset — world, continent or country.
  2. Drop sticky notes over the places that matter and wire them with arrows.
  3. Use Lucide icons as a legend instead of writing one.
  4. For data rather than geography, a generated Peak page draws a real choropleth from a plain object of country values — useful when the point is the numbers, not the places.

Worth knowing

  • The map asset is vector geometry, not a tile map: no streets, no place search, no zoom past the outlines. Outline the story on the board, then link out to a real map for street level.
  • Colour on a map should be measured, not eyeballed. If you have an image of the palette you want, read the hex out of it rather than guessing.

Source: Peak Browser documentation · Verified here — checked against this workspace

Take a deck apart on the board A deck can land on a whiteboard as editable pieces rather than as pictures of slides. 4 min

You end up with: A deck laid out page by page with the edges drawn, then rearranged by hand until the argument is obvious.

Slides → whiteboardGroupsReorder

Ask Peak this

Open my <deck> on a whiteboard, laid out page by page with the edges drawn. Then pull out the slides that cover <theme> into a separate row and put a heading card above them. Show me any two slides that are saying the same thing.

Step by step

  1. Open a deck onto a whiteboard.
  2. What lands is the slide taken apart, not a screenshot of it: text is text, shapes are shapes, and an infographic arrives still written as its document so it keeps editing and merging.
  3. Move, regroup, duplicate and reorder.
  4. When the structure is right, fix the wording back in the deck.

Worth knowing

  • Plots and typeset equations have no whiteboard element of their own, so those come across as pictures. Edit them in the deck, not on the board.
  • This is the fastest way to find the two slides that should have been one — and the three-slide section that is really a single diagram.

Source: Peak Browser documentation

Build

Generate sites, app screens and 3D.

A site in one ask Describe it, then read the code it wrote, preview it live in the same window, and export the folder. Start here

You end up with: A multi-file site you can edit by hand, preview, and export as a folder or a zipped project.

Site BuilderHTML/CSS/JSTailwindLucidethree.jsWorld map

Ask Peak this

Build me a site about <subject>. Dark ground, one accent colour, generous spacing, a hero with a real headline, three sections and a footer. Use no external fonts or CDNs — everything must work offline. Make it multi-page: /, /about and /work, sharing one layout.

Step by step

  1. Start from one of the finished templates, filed by design movement, or from nothing at all.
  2. Peak writes real files — HTML, CSS, JavaScript, images — so read them and change them rather than asking for a rewrite.
  3. Preview as you go. Reuse media that already exists instead of generating more of it.
  4. Export when it is right. A PeakUI project can instead be exported as a native multiplatform Xcode project.
  5. Add optional runtimes where they earn their place: Tailwind for utility styling, Lucide for a real icon set, three.js for 3D, a world map for a choropleth, and Scroll Worlds for scroll-driven video.

Worth knowing

  • The preview is isolated and has no network. No CDN links, no external fonts, no hotlinked images — anything that must load has to be inside the folder. This is the single most common way a generated page looks broken.
  • Link between pages with a trailing slash, like /about/, so the same link also works after the site is exported and served by an ordinary static server.
  • Give every site an entry page before anything else, or there is no root to preview.
  • Split CSS and JavaScript into their own files and link them by relative path. One enormous HTML file is harder for you to edit later, which is the whole point of the thing.

Source: Peak Browser documentation · App Store release notes, v1.6.1

PeakUI: screens that become an Xcode app Write SwiftUI-shaped screens inside Peak, preview them at phone and desktop size, then export a native project. 15 min

You end up with: A three-tab app whose screens export as a runnable multiplatform Xcode project.

PeakUITabViewNavigationLinkSF SymbolsExport to Xcode

Ask Peak this

Build a PeakUI app with three tabs: Home, Library, Settings. Name every view for its screen. Use .formStyle(.grouped) on the Settings form. Use TabView for the sections and NavigationLink for pushes. Screenshot it at desktop and phone size, drive to every screen, then export it as an Xcode project.

Step by step

  1. Decide first: app or website. If the destination is an iPhone, a Mac, or the App Store, build PeakUI screens rather than HTML. Getting this wrong costs the whole attempt.
  2. index.peakui is the root screen. Each tab and each destination gets its own file rather than one enormous first draft.
  3. Use TabView for primary sections and NavigationLink for push destinations.
  4. Check it at the desktop viewport and at the phone viewport, and drive to every screen that is not the default — a detail view behind a link, a second tab, anything below the fold. A multi-screen app is not reviewed until its other screens have been looked at.
  5. Export to Xcode when the preview is clean, and continue there with anything that needs a real framework.

Worth knowing

  • View names must be unique across the whole project, because every screen compiles into one Swift module. Name them for their screen — HomeScreen, SummitRowView — not ScreenView and RowView.
  • An image asset is referenced by name without a leading slash: Image("images/card.png"), never Image("/images/card.png"). The leading-slash form previews and then shows nothing in Xcode.
  • Preview fidelity is honest about itself. Some constructs are faithful, some are approximated with a note, and unsupported ones are reported as errors. Read the note and translate the intent rather than deleting the design.
  • Deterministic local logic works in PeakUI — a calculator, a converter, a validator, a small quiz. Networking, persistence, services and async work belong in Xcode after export.

Source: Peak Browser documentation · Verified here — checked against this workspace

Motion, icons and 3D Draw a logo that draws itself, or describe a small 3D world and let one interpreter play it. 12 min

You end up with: A looping logo animation and a playable 3D scene, both made without writing a line of code.

VectoriseKeyframesGIF / video export3D scenes

Ask Peak this

Trace this logo into vector artwork, then animate the trace being drawn on: opacity 0 to 1 while trim goes 0 to 1 over 1.4 seconds, easeOut. Then export it as a GIF that ping-pongs so the loop has no visible restart. Separately, build me a flying game over a ridge with twenty collectables along a trail and a timer.

Step by step

  1. Vectorise a flat, high-contrast image into path data you can animate.
  2. Animate with keyframes: position, scale, rotation, opacity and trim, staggered with delay so one idea enters at a time.
  3. Export a GIF for a short loop, or video when it needs a soundtrack, or when it runs longer than about ten seconds.
  4. For 3D, describe a world as a document: terrain, an actor, entities to collect, a goal, and a HUD.
  5. Look at the result before calling it done. A still frame grid is not the motion, but it is enough to catch a composition that does not work.

Worth knowing

  • Tracing follows the boundary between light and dark. It is right for logos and line art and wrong for photographs and gradients — say so rather than tracing a photo and presenting it as a logo.
  • Keep an animation to one or two scenes of two to four seconds. It is a loop somebody watches twice, not a film.
  • A letter with a counter — O, A, e — comes out solid rather than holed when extruded.
  • A 3D world is a document, not code: you describe it and one interpreter plays it. Make it finishable — a route of twenty markers across a wide patch at a given speed takes about three minutes, so a ninety-second clock is a game nobody can finish.

Source: Verified here — checked against this workspace

Present

Decks, screenshots and type discipline.

A deck in one ask Ask for slides and it arrives as a card you open — its own tab, editable slide by slide. 6 min

You end up with: A twelve-slide deck you can open, edit by hand, and export as one numbered PNG per slide.

Slides16:9 and 4:3PNG export

Ask Peak this

Make me a 12-slide deck on <subject> for <audience>. 16:9. One idea per slide, at most five bullets, a title plus one supporting line. Include one infographic for the process and one chart. Then render it, check the geometry, and look at the tiled picture of every slide before you describe it to me.

Step by step

  1. Ask for the deck. It arrives on the answer that made it as a card you open.
  2. Click anything to select it, drag to move it, and change its words, colour, position and size in the panel beside the page.
  3. Add and remove elements and slides.
  4. Export: one PNG per slide, numbered so a deck of twelve sorts in the order it is presented in.

Worth knowing

  • A slide whose elements were never given coordinates has them written down on the first edit, so moving one line does not rearrange everything else.
  • A deck can be laid onto a video timeline, where each slide becomes an ordinary clip that trims, fades and moves like anything else.
  • A deck can also be opened onto a whiteboard and edited as parts. Use the board to fix the structure, then fix the wording in the deck.

Source: Peak Browser documentation

App Store screenshots without the argument A deck drawn at the exact sizes App Store Connect asks for, with no alpha channel to get you rejected. 6 min

You end up with: A set of framed screenshots per device size, ready to upload.

iPhone / iPad / Mac artboardsPNG export

Ask Peak this

Make App Store screenshots for <app>: six slides at iPhone portrait size, each with a short headline above a framed device shot, and one palette and one type hierarchy across all six. Then the same six at iPad size and again at Mac size. Export each set as PNG.

Step by step

  1. Ask for the sizes you actually need: iPhone, iPad, Mac.
  2. Changing the size moves nothing on the page — a deck is drawn at whatever size you choose, so the layout survives the change.
  3. Export PNGs. App Store sizes come out without an alpha channel.
  4. Judge them as a set. The reviewer scrolls six images in a row, not one poster.

Worth knowing

  • The missing alpha channel is exactly what a rejected upload is usually missing.
  • One palette and one type hierarchy across the whole set is what makes six screenshots read as one product.

Source: Peak Browser documentation

Why a deck looks like a deck One palette, one type hierarchy, a ground that is actually painted, and shapes only where they hold something. 8 min

You end up with: A deck that is unmistakably one deck with the titles covered.

Slide Design skillGeometry checksTiled review

Ask Peak this

Turn on the Slide Design skill. Before you describe the deck to me, render it, read the geometry report, then look at the tiled picture of every slide and fix what fails: an unpainted ground, a palette that drifts, a title that is not in the same place twice, or a shape holding nothing. Then tell me what you changed.

Step by step

  1. Set the theme once and take every colour from it — ground, ink, muted, accent. Four values, no fifth colour "for variety". Variety comes from size and space, not hue.
  2. Paint the ground on every slide as the first element: a full-bleed shape. Naming a theme does not paint a colour, and a deck on flat black or flat white looks unfinished for reasons nobody can name.
  3. Pick one axis per slide. Either let elements auto-stack, or place everything by hand — never both, because auto-stacked and hand-placed elements do not know about each other.
  4. One title, at most one supporting line, then three to five bullets or one infographic. Not two of those.
  5. Render, read the geometry report, then look at the picture. Both halves, every time.

Worth knowing

  • Measuring is not seeing. A deck can pass every check and still be badly balanced, which is why it is drawn small, tiled into one picture, and looked at before a word is written about it.
  • Empty space is the design. A slide that feels bare usually has the wrong type sizes, not too little decoration.
  • Never scatter circles and triangles to fill a gap, and never hand-build a flow out of rectangles. Use one of the infographic templates instead — they were made for exactly that job and they do not collide.

Source: Verified here — checked against this workspace

Film

Cut, score and narrate on a real timeline.

Cut a film on a real timeline Rows that overlap, so a title can lie over a shot and a music bed can run under all of them. 10 min

You end up with: A finished edit with a title over the picture, a music bed underneath, and a frame you chose at the start.

TimelineTrimFadesTitlesFrame presets

Ask Peak this

Start from the announcement structure. Add my clips to the bottom row, trim the first two, put a title card over the opening shot on a row above, and a music bed under both rows. Fade the title in, fade the ending out, and export the film.

Step by step

  1. Open Intermission → Tools → Timeline Structures. Start from a finished cut — an announcement, a three-point explainer, an open/middle/close story, or a set of lower thirds — or from a blank timeline.
  2. Choose the frame first: widescreen, 4K, square, portrait, vertical, or the exact sizes the App Store wants for an app preview. Everything you drop in is fitted to it.
  3. Drag a clip’s ends to trim it. Drag past the end of a card to hold it longer, and past the end of a shot to repeat it.
  4. Fade handles sit in the corners of every clip. Undo, copy, paste and the delete key all work as you expect.
  5. Put words on a transparent card over the picture, plus bars, discs, blocks and eight symbols, each in one of seven colours — laid over the footage rather than beside it.

Worth knowing

  • Drop a tall photograph onto a widescreen edit and it letterboxes instead of reshaping the whole video. That is the frame decision doing its job.
  • Lay a whole deck onto the timeline and every slide becomes an ordinary still that trims, fades and moves like anything else.
  • There is a title, a chapter heading and an end card, and they are ordinary clips. Do not fight the timeline by trying to write over the picture.

Source: Peak Browser documentation · App Store release notes, v1.6.1

Continue a shot from its exact last frame The next clip begins on the frame the last one ended on, so the camera never cuts. 8 min

You end up with: One continuous camera move built from two or more generated clips, with no seam at the join.

Frame grid reviewLast-frame extractionClip generationJoin

Ask Peak this

Look at the edit as a grid of frames. Take the last frame of the cut, generate a clip that starts from exactly there, add it to the bottom row after the first, then join the clips into a single file. Repeat until the move is as long as I want.

Step by step

  1. Sample the timeline as a grid of frames first, so the continuation is written about the actual piece rather than about a filename.
  2. Extract the last frame of the cut. It is free and instant, and it is exactly the frame the join needs.
  3. Generate the next clip starting from that frame.
  4. Add it after the previous one and export. Join separate clips into one file when you want a single video rather than a playlist.
  5. Repeat the extract-generate-add loop for as long as the shot needs to run.

Worth knowing

  • Extract the frame from the timeline, not from the source file. A source file ends where it ends, which is not where your edit ends.
  • Never regenerate a still to use as the join. A regenerated image differs slightly and the seam visibly pops.
  • A frame grid cannot show you motion between frames or carry the soundtrack. Judge composition from it, and check the actual cut in the timeline.

Source: App Store release notes, v1.6.1 · Verified here — checked against this workspace

The same timeline, read as music Switch the pane and the edit becomes a mixing desk — with a tempo grid, a meter per row, and a bounce. 6 min

You end up with: A mix where the music sits under the voice, and a sound file that matches the video export exactly.

Mixer paneFadersMute / soloTempoBounce to .m4a

Ask Peak this

Switch to the mixer. Voice on row 1 at full, music on row 2 around 0.3 and ducked below the voice. Set the project tempo so the ruler counts bars instead of seconds, and snap the music clips to the grid. Bounce the sound on its own to .m4a.

Step by step

  1. Switch the pane above the timeline to the mixer: a fader, mute, solo and a meter for every row, and a record that turns while it plays.
  2. Set a tempo and the ruler counts bars and beats. Clips snap to the grid.
  3. Set levels per row, and mute or solo to hear one track in isolation.
  4. Bounce the sound on its own to .m4a when you need the audio separately.

Worth knowing

  • The bounce uses the same mix the video export uses, so the two cannot disagree. Do not rebuild the mix somewhere else.
  • Silence removal is an earlier, separate pass. Tighten a talking recording before you score it, not after.

Source: App Store release notes, v1.6.1

Voice, music and the merge Narration and a music bed are separate steps, and one merge puts them on the picture. 7 min

You end up with: A narrated cut whose pauses were removed before it was ever scored.

SpeechMusicAuto EditMerge

Ask Peak this

Write the narration as it should be heard — numbers and abbreviations spelled out. Generate it. Generate a short instrumental bed that sits under a voice. Cut the dead air out of my raw talking recording first, then merge narration and score onto the film with a two-second fade out.

Step by step

  1. Render the picture first, silent. Sound is always a separate step.
  2. Strip the silence from any talking recording. It reports how much came out and how many cuts it made.
  3. Generate narration from text written the way it should be spoken, not the way it reads on a page.
  4. Generate a music bed, quieter than the voice.
  5. Merge picture and audio, looping the bed if it is shorter than the film and fading it out at the end.

Worth knowing

  • Silence removal decides where to cut by loudness alone. It is the right first pass on a recording and the wrong tool for cutting to a length or to a particular moment.
  • Keep the bed under the voice. A music bed that competes with the narration is the most common way a good cut sounds amateur.
  • Spoken narration and a script are different texts. Write the spoken one.

Source: Verified here — checked against this workspace

Research

Find, cite and keep what you read.

Research that shows its working Answers assembled from pages Peak actually fetched, marked as a search result or as read in full. 5 min

You end up with: An answer where every claim traces to a page you can open, and anything untraceable is dropped.

Web researchSource listCitations

Ask Peak this

Research <question>. For every claim, give me the page it came from and mark whether you read it in full or only saw it as a search result. If a sentence cannot be tied back to a page you actually fetched, drop it and tell me you dropped it.

Step by step

  1. Ask the question. Peak fetches pages rather than recalling them.
  2. Read the source list — it is assembled from what was actually fetched, not from what the model says it read.
  3. Follow the good links into tabs, then save them as a session so the research can be closed without being lost.
  4. Ask which parts are least certain. That is where the next search should go.

Worth knowing

  • Anything that cannot be tied back to a fetched page is dropped rather than shown, because a citation that looks right and goes nowhere real is worse than no answer at all. The same rule governs the morning brief.
  • Prefer "read in full" sources for the load-bearing claims, and treat search-result-only lines as leads rather than evidence.
  • Before you quote a date, price or version number, open the page that carries it. A search snippet is a summary, not the page.

Source: Peak Browser documentation

Find what you saved by what it was about That article about state machines you read in June — without the words you happened to use at the time. 6 min

You end up with: A library you can interrogate by meaning rather than by keyword.

Semantic searchOn-device embedding modelLocal index

Ask Peak this

Build a search index over my bookmarks and notes, using an on-device embedding model so nothing leaves the machine. Then find what I saved about state machines, describing it rather than naming it.

Step by step

  1. Install a small embedding model — on your own device, under the MLX settings for search.
  2. Point the embedding source at the local model rather than a cloud provider.
  3. Build the index when you ask for it. It is one file on your device and it is searched locally.
  4. Search by description across bookmarks, notes and optionally history.
  5. Keep the index fresh by rebuilding it when a lot has changed.

Worth knowing

  • Nothing is uploaded, nothing is billed and no key is needed when the embedding model is a local one. The cloud alternative sends the titles and text being indexed to that provider once, when the index is built.
  • Changing the embedding model discards the index rather than searching it. Two models produce numbers that cannot be compared, and a search across them returns confident nonsense.
  • If you would rather not keep a browsing history at all, index bookmarks and notes only. The search still finds what you deliberately saved.

Source: Peak Browser documentation

Reader mode, Markdown and Auto Edit Strip a page to its text, keep it as clean Markdown, then tighten the recording you made about it. 5 min

You end up with: A clean Markdown copy of a long article, plus a tightened recording of your notes on it, in one note.

Reader modeArticle → MarkdownTranscriptionAuto Edit

Ask Peak this

Open this article in reader mode. Turn it into clean Markdown and save it. Then transcribe my voice memo about it, strip the silence out of the recording, and put the transcript in the same note under the article with the link at the top.

Step by step

  1. Read long pages in reader mode rather than fighting the page furniture.
  2. Convert an article to clean Markdown instead of copying it by hand and losing the links.
  3. Transcribe a recording when you want the words.
  4. Strip the silence as a separate pass — you want the words first and the cuts second.
  5. Keep the article, the transcript and the link together in one note.

Worth knowing

  • Transcribing and tightening are two steps on purpose. Cutting first means editing a transcript you do not have yet.
  • Converted Markdown is a much better thing to hand to a model than a copied page, because the headings and links survive.

Source: Peak Browser documentation · Verified here — checked against this workspace

The small built-in tools Background removal, text extraction, image compression, palettes, SVG tracing, 3D extrusion, transcription — most of it on device. 6 min

You end up with: A logo cut out, its real colours measured, traced to vector, and given depth as a 3D object.

Remove backgroundExtract textCompressPaletteTrace → SVGExtrude → 3D

Ask Peak this

Take this logo. Remove its background. Give me the actual palette as hex — measure it from the image, do not guess. Trace it into an SVG path I can animate. Then extrude it with a depth of 12 and a bevel of 1, and tell me which letters come out solid.

Step by step

  1. Remove a background onto transparency for a logo, a product shot or a portrait that has to sit on a page colour.
  2. Extract text from an image rather than retyping it.
  3. Compress an image before it goes into a site, so the page stays quick.
  4. Measure a palette from the image and use the hex it returns.
  5. Trace flat, high-contrast art into vector artwork you can stroke on.
  6. Extrude that artwork into a mesh with depth and bevel, and export it into a 3D tool.
  7. Transcribe a recording when you need the words.

Worth knowing

  • Colour should be measured, not eyeballed. Reasoning from how a picture looks produces a value that is close and wrong, which is worse than obviously wrong because you will ship it.
  • Background removal finds a subject or it fails. It will not invent one, so a busy background needs a different photograph rather than a second attempt.
  • Tracing follows the light/dark boundary. It is right for logos and line art and wrong for photographs and gradients.
  • Extruded letters with counters — O, A, e — come out solid rather than holed. The depth and bevel are sliders, so tune them on the page rather than asking again.

Source: App Store release notes, v1.6.1 · Verified here — checked against this workspace

Deadnet: a search engine over a web that does not exist Peak AI invents a page of results, then writes each destination only when you follow it — and says so on every page, permanently. 4 min

You end up with: A sandbox for seeing how a model fills a gap — with the fabrication marked.

DeadnetInventedGroundedDeep Search

Ask Peak this

Choose Deadnet from the search engine list and search for something. Follow a link, then follow one from that page. Compare the Invented mode against Grounded, which looks up what is true first and invents the sources around it.

Step by step

  1. Links lead to more invented pages, which lead to more. Nothing is fetched in Invented mode.
  2. Three modes: Invented — everything made up; Grounded — looks up what is true first, invents the sources around it; Deep Search — several lookups before writing.
  3. A bar at the top of every page states that the whole web is fabricated, and it cannot be dismissed or removed.

Worth knowing

  • Generated pages cannot reach the public internet, run code, or alter that disclosure. A screenshot of an invented page is otherwise indistinguishable from a real one, which is exactly why the marking is not optional.
  • Set beside the Sources & citations course, this is the useful contrast: there, a source in the list cannot be invented because Peak assembles it from what it actually fetched.

Source: Peak Browser documentation

Intelligence

Bring a model, or run one on your own machine.

Bring your own model There is no Peak account and no Peak inference server. You add a key, or you run a model yourself, and Peak talks to it directly. Start here

You end up with: A model menu that only shows things that can actually answer you.

Settings → APITest buttonOpenRouter sign-in

Ask Peak this

Open Settings → API. Add one key — OpenRouter is the broadest, and it is the only route to image, video, music and speech. Press Test beside it: Peak asks the provider for its model list, which is a real request, because a revoked key looks exactly like a valid one until something is sent.

Step by step

  1. Each row carries a field, a link to where that provider issues keys, and a Test button. Test is not a format check — it asks the provider for its models.
  2. OpenRouter also has a Sign in button. It opens a Safari-backed window, so a saved password or passkey is already there; Peak receives a key scoped to that account and never sees the password behind it.
  3. Ten routes are offered: OpenRouter, OpenAI, OpenCode, xAI Grok, Google Gemini, Moonshot Kimi, Kimi Code, Ollama Cloud, Ollama, and Peak’s own on-device engine.
  4. Kimi is two separate entries on purpose. The pay-as-you-go platform issues keys starting sk-; Kimi Code issues sk-kimi- and uses a different endpoint. Pasting one into the other returns a bare 401.

Worth knowing

  • The menu shows what your keys can reach. Providers you have not configured are hidden rather than offered and then failing — and with no keys at all the full list returns, led by a line telling you why none of it will answer.
  • Model lists are asked for, not remembered. Any provider with a models endpoint is queried at launch and its roster merged in, because names change faster than app releases and a hardcoded list is wrong within weeks. A provider that answers is believed in both directions, so a model it retired disappears rather than lingering until it fails.
  • "Allow models hosted in China" is about hosting, not weights. A model running on your own device is unaffected by it whatever it was trained by — the switch governs where a request is sent, and an on-device model sends nothing.
  • Generation is OpenRouter’s whoever is answering. Without an OpenRouter key those tools are not supplied to the model at all, and Peak says so rather than letting it describe a picture it never made.

Source: Peak Browser documentation

A model that never leaves the machine Turn on Peak’s own engine, download a model, and the prompt, the page you are reading and the reply all stay on the device. 8 min

You end up with: Answers with no account, no key, no bill and no network.

Settings → MLXHugging FacePeak Local

Ask Peak this

Settings → MLX. Turn the engine on and download a model Peak suggests for your device. Pick it in any chat and ask it about the page you are on — nothing leaves the machine.

Step by step

  1. Models come from Hugging Face and sit beside your cloud providers rather than replacing them. A conversation can use either, and switching is a menu away.
  2. Peak suggests a model your device can actually hold rather than the largest that exists, and refuses to load one that will not fit instead of letting the app be killed part-way through an answer.
  3. On a phone that means a small model that starts; on a Mac, a larger one worth using.
  4. Peak Local also appears under Settings → API as an embedding source, so your library can be indexed for semantic search without being uploaded.

Worth knowing

  • A local model is offered a short list of tools rather than all of Peak’s, because reading every tool description costs a small model more than the work usually does.
  • It is told that its list is short, so it says plainly when something is out of reach instead of describing work it has not done. The Minimal skill is the default for this.
  • There are four ways to answer without a cloud provider: this engine, a model borrowed from a Mac over Mesh, Apple Intelligence, and Ollama.

Source: Peak Browser documentation

Borrow the Mac’s model from your phone A 4 GB iPhone holds a model of a few hundred megabytes. The Mac beside it holds one many times larger — and now the phone can ask it. 5 min

You end up with: A small device that is useful rather than a lesser one.

Let Peers Use My ModelsNearby MacPeak Mesh

Ask Peak this

On the Mac holding the weights, switch on Let Peers Use My Models under Settings › MLX. On the phone, open the model menu and look under Nearby Mac — the machine’s models are listed, named after the machine they live on. Pick one and ask.

Step by step

  1. The Mac has to switch it on first. Nothing is shared until you do, and switching it off takes effect on the next request rather than needing a restart.
  2. Models appear on your other devices under Nearby Mac, named after the machine they sit on.
  3. The reply streams back as it is written, over the same encrypted Peak Mesh link as everything else — no account, no cloud relay, nothing that leaves the room.
  4. The Mac answers one request at a time and says so while you wait rather than appearing to hang: two models loading at once is what a machine runs out of memory doing.

Worth knowing

  • This is the answer to a phone being too small for local AI. It does not download the model; it asks the machine that already has it.
  • Pairs with the Mesh course — the same room passphrase and the same link carry it.

Source: Peak Browser documentation

Apple Intelligence, where the system has it Apple’s own model appears in the menu beside Peak’s. No download, no key, nothing leaves the device — and a clear limit worth knowing. 2 min

You end up with: A zero-setup local answer on a machine that already supports it.

Model menuApple Intelligence

Ask Peak this

On a Mac or iPhone running the latest system with Apple Intelligence switched on, open the model menu. Apple’s model is already there. Ask it a question — then ask it to search the web, and watch it decline rather than pretend.

Step by step

  1. No download and no key. Where the system cannot run it, the entry is absent rather than greyed out.
  2. It answers questions. It cannot yet use Peak’s tools, so it will not search the web or build a site.
  3. That limit is deliberate in Peak: Apple runs tools inside its own session, so Peak’s dispatcher is never reached, and claiming otherwise would have the model call a tool that never runs.

Worth knowing

  • Use it for reasoning over what is already in front of you, and switch to a tool-capable model when the job needs the web or the file system.

Source: Peak Browser documentation

Point another app at Peak’s engine While the engine runs, Peak serves an OpenAI-compatible endpoint on loopback that any compatible client can use. 4 min

You end up with: Your editor, script or client answering from the model already loaded on this Mac.

127.0.0.1:52424/v1Bearer tokenMenu bar

Ask Peak this

Turn the engine on. From the Mac menu bar, copy the address and the token. Point any OpenAI-compatible client at http://127.0.0.1:52424/v1 with that token as its bearer.

Step by step

  1. The endpoint exists only while the engine is running. Turning the engine off closes the port.
  2. It is bound to the loopback interface, so nothing on the network can reach it.
  3. Every request needs a bearer token that exists only on this device.
  4. The menu bar shows whether the engine is running and which model it holds, and will copy the address and the token for pasting elsewhere.

Worth knowing

  • This is the same engine your chats use — one model in memory, served to both.
  • Loopback is not a boundary on macOS, which is why the token is required even from Peak itself.

Source: Peak Browser documentation

Skills: capability as a document A skill is instructions, a tool policy, knowledge and templates — deliberately data, never code. Importing one imports a document. 6 min

You end up with: A conversation narrowed to one job, with its cost visible before you turn it on.

Settings → ToolsEleven built-in skillsPer-conversation persona

Ask Peak this

Open Settings → Tools and read a skill’s full instruction text before enabling it. Turn on Minimal for a small model, or Deep Research for a question worth several sources. Then set a different skill beside the persona in one conversation’s own settings.

Step by step

  1. Eleven ship built in: Site Builder, Video Studio, Slide Design, Diagrams, Scroll World, Long Take, Deep Research, Terse, Narrator, Minimal and Visual Browser.
  2. The catalogue shows each skill’s full instruction text, its estimated token cost per message, and — for skills built on generation tools — a warning that they need an OpenRouter key to do anything.
  3. Visual Browser works the tab you are actually looking at rather than the hidden one Peak researches with. It needs Workspace AI and its browser permissions turned on.
  4. Minimal is a handful of tools rather than all of them, and is the sensible default for a small or on-device model.

Worth knowing

  • A skill’s tool policy can only ever narrow what you already permit in Settings → Tools. There is no direction in which a skill can grant itself something you turned off.
  • Because a skill folder is a document rather than software, reading one before enabling it tells you everything it will do.

Source: Peak Browser documentation

What the agent may touch, and what holds it Settings → Tools is the ceiling — nothing widens it — and approval holds requested changes until you accept them. 7 min

You end up with: An agent you can let work without wondering what it just did.

Settings → ToolsRequire approvalAI inspectorHidden viewport

Ask Peak this

Leave Require approval before actions on. Ask for something that writes files, and watch the requested changes queue in the AI inspector until you accept them.

Step by step

  1. Research: web search and a hidden browser that can navigate, click, fill fields, scroll, extract text and screenshot in a viewport that never touches your tabs.
  2. Page media: it can list the images and video a page actually displays — srcset, <picture>, CSS backgrounds and Open Graph tags — and reuse one directly in a site.
  3. Public repositories: list a GitHub repo’s file tree, read files and search across them. Nothing is cloned; files are fetched one at a time and held for that conversation only.
  4. Your library: semantic search over saved bookmarks, notes and history, and media search across images you already generated or attached, so it reuses what exists instead of making a fourth near-identical mountain.
  5. Building: create sites, write and edit files, read them back, diagnose a page by running it, screenshot what it wrote and look at the result before claiming it works.

Worth knowing

  • Palette extraction, design-language extraction and subject cut-out all run on-device with no key needed.
  • Approval is on by default, and worth leaving on while you get a feel for how a given model behaves.

Source: Peak Browser documentation

Images, video, music and speech in a conversation With an OpenRouter key the assistant produces media as part of a chat and places it into notes, sites and videos. 8 min

You end up with: A conversation that hands you finished assets, findable by name afterwards.

Session Settings → Generation ModelsRendered videoSpend ceiling

Ask Peak this

Set the model for each kind under Session Settings → Generation Models — those are shared across every chat, unlike the conversation model. Ask for an image, then attach a source image and ask for an edit rather than a new picture.

Step by step

  1. Images — from a prompt, or from a source image you attach when you want an edit rather than a new picture.
  2. Video — a slow cloud job measured in minutes, with a spend ceiling per conversation.
  3. Rendered video — diagrams, plots, equations and slide-style explainers, rendered on-device and instantly, with type that stays sharp.
  4. Music and speech — tracks and narration, mergeable onto a video.

Worth knowing

  • Generated files are named from their content rather than a timestamp, so the gallery stays searchable and you can reach one by filename in later turns of the same conversation.
  • Rendered video is the one that is instant and on-device. Reach for it when the subject is a diagram or an equation rather than a scene.

Source: Peak Browser documentation

Play & Connect

Games, arcade and the room you are in.

A small 3D game, described not coded Write a document describing a world, and one interpreter plays it — at a fixed tick, from a seeded world. 12 min

You end up with: A three-minute run: a ridge, a trail of markers, a clock, and a minimap you can click to jump the view.

TerrainActorEntitiesTriggersHUD

Ask Peak this

Make a flying game over a ridge. Heightfield terrain with fog that leaves the far ridges just visible, and ninety conifers in the valleys as scenery. Put a trail of twenty collectables along the route — reachable in about three minutes — plus a minimap, a timer and a speed readout. Crashing into the ground above 18 m/s ends the run.

Step by step

  1. Describe the world: heightfield or flat, its amplitude and scale, how many octaves, how wide a patch, and gravity.
  2. Choose the actor — a flyer or a walker — and the camera: chase, first-person, isometric, overhead or free.
  3. Place entities as collectables, hazards or a single goal. The trail distribution is the one that answers "where do I go" from the opening frame.
  4. Add scenery, and make only what should block you solid. Off by default, because most scenery should not be — a hundred solid trees between the player and a marker is a different game.
  5. Add a HUD: score, timer, distance, altitude, remaining, minimap.
  6. Save it, then look at the four views — from above, the opening view, and four and ten seconds in — before calling it finished.

Worth knowing

  • Make it finishable. A tour of twenty markers over a wide patch at a given speed takes roughly three minutes, so a ninety-second clock is a game nobody can finish. This is checked for you, but it is easier to get right than to fix.
  • Only collectables satisfy "collect everything". A world full of hazards satisfies it never.
  • Scenery is most of what makes a world look like somewhere. A bare heightfield reads as a graph, and the same terrain with ninety trees in the valleys reads as a place.
  • A document can pass every check and still be a fog wall thirty metres out, or three greens with no contrast between them. Look at it.

Source: Verified here — checked against this workspace

The Arcade Hub and focus spaces The Intermission area: short games, focus spaces and small local tools, one page away from your work. 3 min

You end up with: A two-minute reset that is one swipe from the tabs you were working in.

Arcade HubFocus spacesLocal tools

Ask Peak this

Open the Arcade Hub. Play one round of a short local game, then set up a focus space for the next block of work. Keep it in the same window as the work — the point is not switching apps.

Step by step

  1. Swipe or click across the root pages to the Arcade Hub.
  2. Short games and focus spaces are local and offline.
  3. Local tools live behind Intermission → Tools, which is also where the video timeline structures are.
  4. Wander back to Landing, Dashboard, Activity Hub or Mesh Hub the same way — the root pages are always there behind whatever tab you have open.

Worth knowing

  • It is deliberately the same window as the work. The value is the absence of a context switch, not the game itself.
  • Intermission → Tools → Timeline Structures is the door to the video editor, which is worth knowing before you need it.

Source: Peak Browser documentation

Peak Mesh: the room you are in Nearby devices find each other over the local network with no account, no relay, and no server in the middle. 8 min

You end up with: Two devices sharing a tab, a note and a game — with the small one borrowing the big one’s model.

Mesh HubRoom passphrasePer-type sharingRemote peers

Ask Peak this

Set a room passphrase. Share tabs, notes and a whiteboard with the other device, and turn everything else off. Then on the phone, borrow the model from the Mac in the room and ask it two questions.

Step by step

  1. Open Mesh Hub on both devices and set the shared room passphrase. Nothing advertises until it is set.
  2. Turn on only the content types you want to share. Each has its own toggle: tabs, chat, notes, boards, whiteboards, sites, decks, animations and games.
  3. A small device can borrow a model from a Mac in the same room: the Mac holds the weights, the phone asks, and the reply streams back as it is written. The Mac has to switch it on first.
  4. It also runs over peer-to-peer Wi-Fi with no router at all, and a written-down address reaches a device on another network directly.

Worth knowing

  • There is no cloud relay and no account. Nothing leaves the room, and no server of Peak’s sits in the middle.
  • Share the least you have to. The per-type toggles exist so you can share one whiteboard without sharing your whole workspace.
  • A phone too small to hold a model is not shut out of local AI — it borrows one from the Mac on the same network.

Source: Peak Browser documentation

A research piece, end to end

From a question to a deck, keeping every source attached the whole way.

  1. Summon it, then feed the one input
  2. Research that shows its working
  3. Reader mode, Markdown and Auto Edit
  4. Block notes that hold structure
  5. A deck in one ask

A product launch

The materials a launch needs, in the order you actually need them.

  1. Projects, and the library of everything Peak made
  2. A site in one ask
  3. App Store screenshots without the argument
  4. Cut a film on a real timeline
  5. Voice, music and the merge

An afternoon of thinking

No deadline, no deliverable — just get the shape of the thing right.

  1. The whiteboard, properly
  2. Maps and icon assets on the canvas
  3. Take a deck apart on the board
  4. Motion, icons and 3D
  5. Find what you saved by what it was about

Set up intelligence, privately

From no model at all to one running on your own hardware, and a phone borrowing the Mac’s.

  1. Bring your own model
  2. A model that never leaves the machine
  3. Borrow the Mac’s model from your phone
  4. Skills: capability as a document
  5. What the agent may touch, and what holds it

Something to play with

Build a small 3D world, then put it in your pocket and hand it to the room.

  1. A small 3D game, described not coded
  2. The Arcade Hub and focus spaces
  3. Peak Mesh: the room you are in

Courses that run together

A single course teaches one move. These are the orders they are actually used in — each step below is a course, and following one straight through produces a finished piece of work rather than five unrelated exercises.

Peak changes faster than a page does. Where a course and the app disagree, the app is right — and the documentation is regenerated with each release.