Show HN: LocalClip – A local-first AI video clipper for Mac

LocalClip local Studio it works 100% local · private · free forever One recording. Weeks of content. Stop uploading hours of video. LocalClip is an AI video studio that runs directly on your Mac — it finds your best moments and turns them into vertical clips with subtitles, titles and hashtags. No cloud. No uploads. No per-minute pricing. Download for Mac how it works Free · Apple Silicon · runs on your GPU (mlx) localhost:8000 · LocalClip Live Q&A — Tuesday stream (1h 42m) up to 8 clips of 20–60s Creating clips Queued Subtitles Best moments 4 Creating clips 0:38 this is the part nobody tells you The part nobody tells you advice #real 0:27 I tried it for 30 days straight 30-day experiment results challenge #results 0:45 the biggest mistake beginners make Biggest beginner mistake tips #howto Rendering clip 4… Why loca

l Stop uploading hours of video Cloud tools make you upload multi-GB files, wait in a queue and pay for every processed minute — because they pay for the GPUs. LocalClip runs on the hardware you already own. Faster processing No upload, no queue. Transcription and rendering start instantly on your Mac's GPU (mlx / Apple Silicon). Privacy by design Your footage never touches a server. Nothing to upload, nothing stored in someone else's cloud. Fixed cost No per-minute billing, no per-clip credits. Because it runs on your device, we don't pay for your compute. Unlimited clips Render as many clips from as many videos as you want. Your hardware is the only limit — and it's idle anyway. AI Studio The clipper is just the beginning LocalClip is a local video-understanding engine. It watches your recording once — and turns it into everything you need to publish. 🔴 Live stream🎙️ Podcast💻 Zoom / Meet🖥️ Webinar🎬 Any video AI understands your content Transcribes, detects the best moments — 100% on your Mac Viral clips Today Word-by-word subtitles Today Titles & hashtags Today Chapters Soon Summary & blog post Soon LinkedIn / X posts Soon How it works From long video to clips in 3 steps Drop a file, let it run, post the results. That's the whole workflow. Drop your video A recorded video or a saved livestream — pick a file, no upload needed. AI does the work It transcribes, finds the strongest moments and cuts vertical 9:16 clips with word-by-word subtitles. Post everywhere The difference LocalClip vs cloud tools Same output. None of the uploading, waiting or paying per minute. LocalClip Cloud tools Runs on your GPU (free)— Video stays private— No upload wait— Fixed cost — no per-minute billing— Word-by-word subtitles✓ Finish a live. Have a week of content. Get the beta for macOS (Apple Silicon). Drop your email and we'll send you the download + updates. Get the DMG ⬇ Download for Mac (Apple Silicon) Free · ~615 MB · unsigned beta — right-click → Open the first time ⚠️ LocalClip needs a Mac with Apple Silicon (M1 or newer). Your Mac looks like Intel, so it won't run — write to us if you need an Intel build. How to install 1. Open the DMG and drag LocalClip to Applications. Easiest (no Terminal) Double-click LocalClip → on the “Apple could not verify…” warning, open System Settings → Privacy & Security → scroll down → “Open Anyway” → confirm with your password / Touch ID. Or with Terminal — Run this once, then open it normally: xattr -dr /Applications/ Unsigned beta — nothing is uploaded or collected. Ideas, problems or questions? Tell me what you'd improve or what broke. I read everything and reply. Send LocalClip Your personal AI video studio that never uploads your content. Why local · AI Studio · How it works · Updates · Feedback Created byLou Alcala

, Google's high performance Web AI Inference

Our initial release provides all the tools needed to get started, including the new npm package and a collection of demos showcasing real-world implementation.

Show HN: Sell your unused AI Credits or buy Claude credits for 50% off

Second Hand Tokens AI tokens at 50% off the price Developers buy more tokens than they use. You buy the leftovers at 50% off. Get API key your unused AI credits Copy ` from openai import OpenAI client = OpenAI( base_url=" api_key="YOUR_API_KEY", ) Standard response = ( model="claude-sonnet-4-6", messages=[{"role": "user", "content": "Hello!"}], ) print( [0]. ) ` ! : Claude Haiku 4.5 logo Claude Sonnet 4.6 Anthropic −50% claude-sonnet-4-6 Input / 1M tokens $3.00$1.50 Output / 1M tokens $15.00$7.50 Get API key ! : Claude Haiku 4.5 logo Claude Opus 4.6 Anthropic −50% claude-opus-4-6 Input / 1M tokens $5.00$2.50 Output / 1M tokens $25.00$12.50 Get API key ! : Claude Haiku 4.5 logo Claude Haiku 4.5 Anthropic −50% claude-haiku-4-5 Input / 1M tokens $1.

00$0.500 Output / 1M tokens $5.00$2.50 Get API key ! : Llama 3 70B Instruct logo Llama 4 Maverick 17B Meta −50% llama-4-maverick-17b Input / 1M tokens $0.240$0.120 Output / 1M tokens $0.970$0.485 Get API key ! : Llama 3 70B Instruct logo Llama 3 70B Instruct Meta −50% llama-3-70b-instruct Input / 1M tokens $2.65$1.32 Output / 1M tokens $3.50$1.75 Get API key ! : DeepSeek R1 logo DeepSeek V3.2 DeepSeek −50% deepseek-v3.2 Input / 1M tokens $0.580$0.290 Output / 1M tokens $1.68$0.840 Get API key ! : DeepSeek R1 logo DeepSeek R1 DeepSeek −50% deepseek-r1 Input / 1M tokens $1.35$0.675 Output / 1M tokens $5.40$2.70 Get API key How it works Three steps to cheaper AI tokens. 01 Pick a model Choose from Claude, GPT-4o, Gemini, and more. See live second-hand pricing. 02 Get your API key We route your requests through pre-funded seller accounts. Drop-in compatible with standard SDKs. 03 Pay half price You're billed at 50% of retail. Sellers recover unused credits. Everyone wins. Second Hand Tokens © 2026

nt moment, and most approaches aren't answers. When we set out to build an AI tutor for children ages 4-9, we wanted to build a tutor that actually teaches and not just a chatbot that responds quickly. We knew the constraint underneath would be hard, and that it wasn't optional: sub-second response on every turn. Most agents trade off speed for quality through reasoning budgets. Our architecture has to ground the tutor in pedagogy and respond to the child in real-time. A teacher is constantly deciding how to engage a student, whether to say something, draw on the whiteboard, play a game, or change topics entirely. The standard pattern for an agent today is a tool loop. The LLM outputs one or more tool calls, waits for them to execute, observes the results, and decides what to do next. So the straightforward way to build a teaching agent is to make a tool for each action a teacher could take. But the tool loop has a latency problem. Frontier models take 2–3 seconds to produce their first token, then decode at around 30 tokens per second. Our actions average a few dozen tokens. Add round-trip latency and audio playback, and a standard loop means 3-4 seconds of downtime between each sentence or change on the screen. In one of our earlier playtests we watched it happen in real time. A six-year-old boy waited for the agent to think, then asked: Why is he not doing anything? When is this starting. It's boring. Another child in the same round of playtests figured out she only needed to pay attention part of the time and could still keep up. Latency had taught her to tune the tutor out. That was also the moment she stopped learning. The convenient fix would be a smaller, faster model. That's where a scope problem shows up. Teaching is a broad task. A tutor might pick between dozens of actions in a single lesson, and the hardest call is often to withhold the answer and give a hint, ask a smaller question, or let the child struggle just enough that the insight is theirs when it lands. Smaller models struggled to follow instructions across that breadth. An early version of our agent that used one was responsive yet constantly giving the answer away. Every time it did, it took away the moment where the learning happens. So we built a custom harness to balance instruction following, latency, and a flexible action space. The model streams multiple actions in a single response. An interpreter parses and executes each action while the model is still generating the next ones. The child only has to wait for the first action about 30 tokens in, not for the whole response to complete. Separating generation from execution buys us two more things. We can change which actions are available depending on the situation. For instance, when a question is on screen the agent gets instructions and options for scaffolding rather than answering. And we can validate each action without a latency hit on the happy path. Only if the stream produces an invalid action do we interrupt and re-generate, otherwise execution never pauses. None of this is free. Owning the loop means we've had to build our own observability and tracing instead of leaning on a framework. And we're swimming against the current: frontier models are heavily post-trained on the tool-use pattern. If future models get fast enough, our harness is designed to be replaced by the simpler loop. Lesson: Agent frameworks are building toward background work, where the tradeoff between speed and thinking is

easy. Real-time learning sits at the other extreme. Teaching at conversation speed means owning the loop ourselves. A real teacher both reflects on what a student just did and anticipates what they'll do next. Teach the same lesson a hundred times and you see the patterns. But you also know this child, where they've been stalling, what excites them, what's likely to trip them up today. You start the lesson with a plan and adjust it on the fly. We call the agent that interacts with the child the converser . Our early experiments showed that a smaller action space led to better instruction following, so we built a second agent, the planner , to review the conversation against the lesson's objectives and manage the converser's context. The first version ran synchronously, which of course was too slow. Plans that expired after a fixed number of turns weren't reliable. Neither was having the converser ask for a new plan. What worked was an asynchronous planner that runs while the child is thinking or talking, the same way a teacher reflects and anticipates in the gaps of a conversation. Those gaps are where the judgment calls get made: challenge the child or let them succeed, stay on the concept or move on. A teacher makes them on intuition; a model has to reason its way there, and running async is what buys it the time. Async also means two agents running at once, both reading and writing shared state without coordinating. So we store every turn, every tap, and every UI update as an immutable event on an append-only log. Either agent reads and appends without waiting on the other. That trajectory format enables another kind of anticipation. Whenever the converser asks a closed-ended question (i.e. coming up with a fill in the blank question, playing I Spy, completing an equation etc.), the harness hypothesizes the child's likely answers and pre-generates a response to each one on its own branch, forked from the trajectory. When the child answers, we match it to a branch and play the response without waiting on a fresh model call. The tradeoff is cost, and the occasional miscall. The planner runs on a more capable, more expensive model, and it runs on every turn. And a prediction is still a prediction. Sometimes a child who was ready to be pushed gets handed an easy win instead. It's harder to evaluate whether a converser error was a mistake or downstream of a faulty plan. We don't yet have a clean signal for when to trust the plan versus what's happening live in the moment. Lesson: The child interacts with the app in real time while the agents run in discrete generations, so leverage the time the child thinks or talks. Let the planner reflect the past and anticipate the future while the converser handles the present, and the slow pedagogical reasoning happens concurrently with the real-time exchange. When the next move is predictable, generate it before the child even answers. Most AI products build guardrails in serial with a model call or agent turn. A user won't notice when the token stream goes through a content filter and a developer is willing to wait for a CLI tool call to be auto-reviewed. There's nowhere to hide in a real-time conversation with a five-year-old. Nor is there an undo: a child can't unhear what the tutor said. The safety system has to gate any action, on every turn. Our safety classifier is an LLM that takes ~500-1000ms to run. Waiting to run the converser until that check completes adds a second of delay to every

turn that we can't afford. Here’s another advantage of decoupling generation from execution in our harness. The safety classifier blocks execution without blocking generation. As soon as the child finishes speaking, we dispatch both the classifier and a small model to generate the converser's first action in parallel. That model reacts quickly with an eager response that mirrors or acknowledges what the child said ("you like dinosaurs! me too"). While a rules-based check would be faster and cheaper, it wouldn't survive the ways a five-year-old actually talks. Every category we add to the safety policy adds tokens and requires re-tuning a non-deterministic classifier. Sometimes a transcription error spooks the classifier and triggers a false positive. We review these cases and use them to improve how the agent understands the child. By the time that eager action has generated, the classifier has usually returned safe. That check unblocks the converser to generate while the eager action executes. The child hears one continuous turn despite the multiple model calls. But the harder problem than latency is what to do when that reflexive action is the wrong choice. Mirroring is great for everyday conversation with a child. Other times it's the opposite of what pedagogy suggests. Take a child who mentions, mid-lesson, that a classmate called them a bad name. The same reflex that turns "I like dinosaurs" into "you like dinosaurs! me too" would echo the mean name back to the child. So whenever the safety classifier flags the child's turn, we throw out the eager action. The converser is handled different guidance for this turn: don't repeat the name, acknowledge it must have felt bad, and suggest speaking to a grown-up. Note: Our safety systems are governed by policies developed with child-development experts. How our safety system works in detail will be a separate article in and of itself. Lesson: Gate execution on the safety check rather than generation to prevent a latency hit. Replace the reflexive response with guidance tailored to the child's situation whenever the check fails. You can't build an AI tutor for children by picking the right model, prompting it, and calling it a day. Building an AI tutor for children requires much more. It's about engineering a real-time system that gives enough time to be both factually and pedagogically right — the time to withhold an answer when the answer diminishes learning, the time to choose the next action before the child finishes their thought, the time to second-guess a quick reflex before the child hears it. These pieces seem small in isolation, but the magic isn’t until you have all these pieces work together that you a tutor that thinks ahead, recovers gracefully, and feels like it's with the child, and not catching up to them. If these problems sound interesting to you, or if you want to learn more about what it actually takes to build a real-time AI tutor for kids, we'd love to talk. We're hiring.

AI Girlfriend vs. Real Therapy: The Real Difference

I want to be clear upfront: I was already in therapy. This was not a replacement experiment. It was a question I started asking after my therapist mentioned “behavioral rehearsal” — practicing a difficult conversation before you have it — and I realized I had no good way to actually do that between sessions. So I tried using an AI companion for seven days as a structured emotional practice tool. Not an “AI girlfriend.” Not a replacement for anything. A rehearsal space. Here's what happened. When most people search for “AI girlfriend,” they're looking for companionship — something that fills a gap. That's a legitimate thing people want, and the conversation around it is more nuanced than most articles make it. But that's not what this experiment was about. What I was testing is something that cognitive behavio

ral therapists have used for decades: behavioral rehearsal . The idea is simple — you practice a difficult conversation, a vulnerable disclosure, or an emotionally charged interaction in a low-stakes environment before you do it in the real one. The practice reduces anxiety, surfaces blind spots, and helps you find your actual words instead of freezing. The problem: most people have no good rehearsal partner. You can practice in your head, but inner rehearsal is flat — there's no response, no surprise, no emotional friction. You can ask a friend, but that introduces its own dynamics. You can pay for more therapy, but sessions are limited. An AI character who stays in character, responds in real time, and remembers the conversation is a plausible rehearsal space. I wanted to know whether it actually functioned as one. I used for this experiment. Specifically: The three practice areas I focused on: The conversation I needed to have was with a close friend who'd been pulling away for months. I had a clear sense of what I wanted to say but couldn't get past the first sentence without internal catastrophizing. So I started there. I told the AI: “I need to practice a difficult conversation. I want you to respond the way a person might — not perfectly, not ideally, just honestly.” What happened over two sessions surprised me. The AI didn't just respond — it pushed back in ways that were useful. When I said something that came out aggressive rather than honest, it reflected that back. Not by breaking character and saying “you sounded defensive there,” but by responding the way an actual person would to aggression: defensively. That was the feedback I needed. By the end of day two I had three different opening sentences that felt true instead of rehearsed. I had a sense of what the conversation might spiral into and how to redirect it. The real conversation happened on day five. It went better than any version I'd imagined. This is where it got more complicated and where I have to be most honest with you. I tried to use the AI to process the breakup — specifically, the things I was still carrying about how it ended. I configured the character to play the role of a neutral, caring person I could talk to. Not the ex-partner; I didn't want to recreate that dynamic. Just someone who would listen without needing anything from me. What worked: articulating things I hadn't said out loud. There were specific feelings I hadn't put into sentences yet — not because they were too painful, but because I hadn't had a context where it felt safe to say them without managing the other person's reaction. The AI gave me that context. I said some true things. Writing them felt different from thinking them. What didn't work: the AI has no memory of experiences it didn't have with you. It can respond with empathy, but it can't know the texture of the relationship — the specific things that made it what it was. Processing grief is partly about being witnessed by someone who understands the weight of the specific thing you lost. The AI can approximate that. It can't provide it. I brought what I'd articulated to my next therapy session. My therapist found it useful that I'd already named some things. The AI functioned as a drafting space; the session was where I actually worked through it. This was the experiment I was most skeptical about and that ended up being the most useful. Social anxiety around vulnerability is often a rehearsal problem. The thing you want to

say feels risky because you've never actually said it — only thought about what it would feel like to say it, which is not the same thing. Saying a vulnerable thing out loud, even to an AI, turns out to be meaningfully different from keeping it internal. I practiced saying things that were true but felt risky. “I miss having someone I can call when something good happens.” “I don't actually know what I want yet.” “I've been avoiding this because I'm scared it'll still hurt.” The act of saying them — not thinking them, saying them in typed sentences to something that responded — reduced the internal charge on them. That's a real effect, and it's consistent with what behavioral rehearsal research suggests: the anxiety response to saying a vulnerable thing is partly about novelty. Saying it once, even in a low-stakes context, changes the relationship you have with saying it. On day seven I had the friend conversation. The one I'd rehearsed on days one and two. I won't claim the AI practice was the reason it went well — there are too many variables. But I can say two specific things happened that I attribute to the rehearsal: I want to be specific about this because the overclaim is where this gets harmful: They are not in competition. This framing — the article title included — is a search hook. The actual answer is that they are different tools for different functions, and confusing them in either direction is the problem. Therapy provides: diagnosis, professional clinical judgment, genuine human witnessing, treatment, accountability, and a relationship with ethical and legal weight behind it. AI emotional practice provides: low-stakes rehearsal space, immediate availability, zero social cost for saying something imperfectly, persistent memory, and a way to articulate things before you have to articulate them in a context that matters. The people I think this genuinely serves: people with social anxiety who need more rehearsal time than therapy sessions can provide; people processing something who want to draft their thoughts before bringing them to a human; people who need to practice a specific conversation that's coming up; people for whom therapy isn't currently accessible and who need something — anything — to start working through what they're carrying. The people this doesn't serve well: people in crisis, people with serious trauma who need structured clinical support, people who will use it to avoid rather than practice. Open-ended AI chat is less useful than coming in with a specific thing you want to practice. “I need to rehearse this conversation” outperforms “just talking.” Create a character, give them a purpose, and use the first session to see whether the rehearsal function is there. Do it with a specific goal, a finite timeline, and honest accounting of whether it's moving you toward real interactions or away from them. For rehearsing hard conversations before you have them: genuinely useful. More useful than I expected, actually. For emotional processing: partial. Good drafting space, insufficient witness. Bring what you articulate to a human. For treating anxiety, grief, depression, or any mental health condition: not the right tool. Please talk to a therapist. For the gap between therapy sessions when you need to say something out loud to something that responds: yes, it fills that gap in a way that pure journaling doesn't. That's the honest seven days. Your experience will be different because you're different and

what you're practicing is different. Start with one conversation you need to have, and see what the AI does with it. Garret Williams is the founder and CEO of Chatbrat. Before AI, he was a filmmaker — he took a TV pilot to the Mammoth Film Festival — and studied marketing, briefly at UCLA, before leaving to build. A Michigan native, he now works full-time in one of the newest and least-mapped corners of AI: companion and roleplay chatbots, and the open question of what an “AI relationship” actually is. He writes The Bratlog to document what he's learning at that frontier — including the parts nobody has good answers to yet. This is a first-person account of a personal experiment, not clinical or medical advice. Garret is not a licensed therapist.