PH热榜 | 2026-07-01

Wow, the retrieval-over-generation point is really interesting. Four words from a keyboard carry way less signal than a full chat prompt, so I guess the tricky part is guessing whether I want a search, a doc or a triggered action. When the intent is ambiguous, do you commit to one guess and let me correct? Congrats on another great launch!

How customizable are the skill keys over time? Can users create layered workflows or conditional actions?

This feels like someone questioned a very basic assumption: why is the keyboard only for text?

Curious how far the skill ecosystem can go once developers start connecting APIs.

so the whole thing hinges on that Acti Bar hold gesture reading my intent right the first time, which is where most keyboard agents die. how often does it actually nail the intent vs make me rephrase, and can a Skill Key fire a real action like a Calendar invite without me ever leaving the text field?

Can Acti understand the context of the current conversation, or does it only react to the exact text being typed?

Congrats on the launch, folks. Genuinely think this is one of the more interesting "agent surface" bets I've seen on PH lately.

Also, just curious, when a Skill Key needs to pull from multiple sources at once (say, "find a Meet link AND check if it conflicts with my calendar"), does Acti chain those actions automatically, or does the Skill builder need to explicitly sequence each step? Wondering how much reasoning happens under the hood vs. how much the no-code builder has to spell out.

As someone who has worked on mobile products before, I honestly think the hardest part here is reliability. Keyboard interactions need to feel instant or users lose trust immediately. Pretty impressed by how responsive ACTI already feels in beta.

This is one of the first AI products where I immediately understood why the keyboard is the right interface. It's everywhere already. Email, chat, docs, browsers, forms. Putting the agent there instead of inside another standalone app actually makes a lot of sense.

This is probably one of the few AI products lately where I can clearly explain the daily use case after trying it myself. Most people instantly understand the value once they experience reduced app switching.

I appreciate that the interaction model is intentionally constrained. Long press the space bar, trigger the action, continue typing. There's discipline in not overcomplicating the interface.

Most AI tools want another tab open. ACTI feels much lighter

Putting the agentic layer inside the keyboard is smart since that's the one surface every app shares. Curious how you're handling context that spans apps, does Acti see what's on screen or just what gets typed?

The mobile first bet feels underexplored while everyone's chasing desktop agents.

P.S. might be worth putting on StartupBase too, mobile-first tools like this stand out there.

Finally got the hang of just holding the bar to grab my calendar and meet links mid chat. Way smoother than copying over from another tab.

Skipped the tab-hopping for a Notion doc and got it in seconds, which felt weirdly novel. The hold-to-activate gesture is a nice touch too.

This is probably one of the few AI products lately where I can clearly explain the daily use case after trying it myself. Most people instantly understand the value once they experience reduced app switching.

The value only clicks when you imagine the number of tiny app switches it removes every day

For custom Skill Keys, how easy is it for someone non-technical to connect something like Notion or Calendar and make it actually useful in daily chats?

The no-code angle sounds promising, but I’m wondering about the learning curve once you have a few keys set up does it start suggesting them intelligently based on what you’re typing?

The "without leaving the conversation" part is the real pitch here, most assistant keyboards still make you context switch to a browser or app once you need actual info. Curious how it handles disambiguation - if I type "nearby restaurants" does it use device location automatically or ask first? Also does it get disabled inside password fields for privacy, or does it try to be smart everywhere?

Can Acti connect to any app with an API, or only the ones officially supported?

Does Acti learn from repeated behavior patterns, or are workflows always manually triggered?

I'm interested in how the keyboard avoids becoming visually overwhelming once users accumulate lots of skills and integrations.

What happens if an action fails halfway through? Is there a retry or recovery flow built into the experience?

After using ACTI for a bit, I think the real value is reducing interruption cost. Even tiny context switches pull you out of what you were doing mentally. Keeping actions inside the same screen sounds minor until you experience it repeatedly.

I've always thought keyboards were massively underutilized as a system surface. They occupy a huge amount of screen time across every app, yet almost nobody has treated them as programmable environments until recently.

I like that the product focuses on execution instead of just text generation.

This looks great! Any plans for using your own models or using local models?

how does Acti actually understand my intent if I'm just typing plain text without any special commands or syntax?

Hey PH 👋 Martí here, co-founder of Humalike.

What is Humalike? The behavioral infrastructure for humanlike AI agents. The social skills your agents have been missing.

The problem
A few months ago we built an AI community manager. The second it hit a group chat, everyone knew it was a bot. It talked over people, never knew when to shut up. More features didn't fix it. Today's models are capable enough. Smart enough. Fast enough. But we still feel they don’t fit in the room.

The solution: 7 behavioral APIs

• Turn-Taking (Flagship): Knows when to speak and when to stay silent (bundles all other APIs in one).

• Theory of Mind: It gives your agent a sense of what people really think and feel.

• Norms: Reads the group’s tone and responds the way it’s accepted here.

• Persona: Improve presonality so it’s Opinionated, takes sides, backed by real community data

• Social Memory: It gives your agent a memory for people, who they are and what matters to them.

• Social Signals: Catches the pause before sending, a removed reaction, and an edited message.

• Social Observability: Sees who’s engaged, who’s bored, and who’s annoyed.

Model, use-case and stack agnostic, built for groups, not just 1:1.

Extra highlights

• 💸 $20 in free tokens to start building

• 🔌 One-shot integrations with Hermes, WhatsApp & Telegram

• 📄 Backed by in-house research: LoSoNA (social-norm benchmark) + HUMA (a human-passing group facilitator)

• 🔒 SOC 2 / ISO 27001 in progress
  

Who It's for: Anyone building agents that must feel human, AI companions, NPCs, tutors, voice agents, groups, humanoids. If you've ever shipped an agent that was smart but experience using it felt wrong, Humalike is for you.

What we'd love from you: Grab your $20 in tokens, and tell us, how did our APIs improve the experience? Try with Hermes, Openclaw, or any agent you have deployed! We'll be here all day reading every comment, your feedback shapes what we ship!

Backed by the first investors in ElevenLabs, Revolut & more.
Built by a tiny 🇪🇸×🇵🇱 team that hasn't slept much :))

The Turn-Taking API is the part that jumps out at me. I build voice AI that calls elderly parents every day, and the single hardest thing has been the bot cutting people off. Older folks pause mid-sentence to find a word, and every VAD setup I've tried reads that silence as their turn ending. How does Turn-Taking handle long, uneven pauses? Is it purely acoustic timing, or does it factor in whether the thought is actually complete? Following to see where the benchmarks land.

Looks like "groups, not 1:1" framing is the one most people might underrate. Really good! Turn-taking in a 2-person chat is mostly a latency problem, but the second there are 4 people in the room the agent has to decide whether to speak at all, which is a completely different thing.

Wonder when you're stack-agnostic, how do you actually capture a deleted draft or a pulled reaction? I guess on most platforms that event never leaves the client

Theory of Mind is the hardest one to get right, honestly.

How are you evaluating whether it's actually working vs just inferring emotions in an obvious way?

Hey everyone! I'm Mateusz, co-founder and CTO of Humalike 👨‍💻

We put a lot of effort to transform our in-house research and know-how gained in the past year into a product everyone can use. Today we are releasing 7 APIs you can plug-in to your agent or product

Research

Our team includes people previously working at NVIDIA, Revolut, TSMC and High Frequency Trading firms. Making AI behave in humanlike way in social scenarios is a hard hard hard problem. We publish part of our research, feel free to give it a look:
https://arxiv.org/abs/2511.17315
https://arxiv.org/abs/2606.14600

Security
We are in the process of getting SOC 2 compliant which is gold standard of security, reliability and safety of data 🔒

Hey! Maks here, Founding Engineer at Humalike 👋

Besides the raw APIs, we also open-sourced a Hermes Agent plugin that plugs them straight in (Turn-Taking, Persona via `/soul enhance`, Theory of Mind and Social Learning), so you get the behavior without writing the integration yourself. ⚡️

If you're running a Hermes agent it's a one-drop-in. If not, the code is a decent reference for how the APIs fit together. MIT-licensed: https://github.com/Humalike/hermes-humalike-plugin 🔌

If you have any questions, feel free to reach out to me anytime, happy to help. 🙌

Hey everyone, I’m Mateusz, founding researcher at Humalike.

For me, the interesting problem is the gap between intelligence and behavior. Agents are getting very capable, but they still often feel awkward in real conversations.

Humalike is our attempt to work on that missing layer.

Hey! Ignacio here, Founding Product Engineer at Humalike.

We encourage you to integrate our APIs into your agents and watch their performance improve immediately in social scenarios. Trust me, you won't want to go back to your old agent behaviour. ;)

P.S. Enjoy your free credits on sign-up!

congrats!!!

The social observability feature seems really interesting. It’s something I feel humans can do very naturally so It’ll be interesting to see agents being able to read the room just like humans.

Will try this out with my agents!

Amazing stuff!

Are you guys planning on launching a separate agent, or just the API's?

The community manager anecdote is universal, I've watched it happen in Discord servers, Slack workspaces, and group chats. The failure mode isn't the bot being wrong, it's the bot being present. Silence has always been the harder signal to model because there's no reward function for "you correctly didn't do anything."

The split between Turn-Taking and Theory of Mind is what I'd want to understand better. In practice they feel related but the failure modes are different, an agent can have decent turn-taking (waits for pauses, doesn't interrupt) while still fundamentally misreading what people actually want from the conversation. And vice versa: an agent can read the room well emotionally but still fire at the wrong beat. Is Turn-Taking gated by Theory of Mind under the hood, or are they genuinely independent modules that can score high/low separately?

Rooting for this. Building social behavior as infrastructure rather than as prompt tricks is overdue.

This is a really interesting angle — most of the conversation around AI agents focuses on capability (can it use the right tools, in the right order?) but the social layer is almost always missing. I've been studying agentic AI recently and the gap between 'task completed correctly' and 'response that feels right for the situation' is huge. How are you thinking about measuring whether an agent is actually reading the room vs. just following social scripts?

Can developers tune how proactive or reserved an agent behaves for different communities?

The "groups, not 1:1" framing is what got me.

I run a 2k-person Discord and tried putting an agent in the busy channels. In a 1:1 DM it's fine — but the moment 5 people are going back and forth, it either spams every message or freezes and says nothing. There's no in-between.

So my question on Turn-Taking: in a fast group thread, is it scoring "should I speak right now" per incoming message? Or does it hold a running read of the whole conversation and wait for a real opening?

And can I bias it toward "lurk more" — for a channel where I only want it to chime in occasionally?

Congrats on the launch, this is such a sharp problem to tackle!! The Social Signals piece hit home for me, on the recruiting side we run into the exact same thing: a candidate going quiet after a great call, or an interviewer's one line notes not saying what they actually mean. The signal is almost always there, it's just messy, not absent. Curious how much of Turn Taking transfers from group chats to something like a one on one interview flow?

Framing AI social skills as infrastructure rather than a feature is the real unlock here, most teams bolt on personality as an afterthought but treating turn-taking and social memory as primitives changes how you architect agents from day one.

Congrats on the launch! This hits close to home. The gap is never how smart the model is, it's exactly what you're describing: agents that don't read the room. Turn-Taking and Persona look genuinely useful for our customer-facing agents. Grabbing the free tokens now, how hard is it to wire the WhatsApp integration into an already-built agent stack?

Congrats on the launch! How does this play with the one-shot integrations? I'm thinking about testing with WhatsApp groups where context switches constantly, does the agent keep social memory across platform boundaries if the same group moves between channels?

The strongest version of this is not making agents feel more human; it is helping them know when not to act. Turn-taking, memory, and observability are exactly the boring layers that make an agent usable in a real group instead of just impressive in a demo.

the turn-taking and social observability APIs make sense to me, but persona/norms feel like they could go wrong in a way that's hard to detect. if the agent reads the room and picks a side or a tone to fit in, how do you catch it drifting into something the team didn't actually want, before a customer sees it

Social intelligence feels like a missing layer for many agents. Tool use is getting better, but reading context, timing, and group dynamics is what makes an AI teammate actually feel usable.

Congrats! How does social memory balance personalization with user privacy? can users control what the agent remembers?

Congrats on the launch! 🎉 How does Turn-Taking decide when an agent should jump into a group conversation vs. hold back?

"Knows when to speak and when to stay silent" that line is doing a lot of work, and it's the whole ballgame. I run Pushary (permission requests shot to your lock screen so you always come back to a completed task), and knowing when not to fire is harder and more valuable than the sending itself. Nice to see someone treat social behavior as real infrastructure instead of a clever prompt, and build it for groups rather than just 1:1. Congrats on the launch, rooting for you. 🚀

As a community manager, I'd use this immediately for Discord and Slack community assistants. :D

Is there analytics showing why an agent chose not to respond? That would be incredibly valuable for debugging.

How does Humalike adapt when community norms evolve over weeks or months instead of remaining static?

I'd love to see benchmark videos comparing baseline agents against Humalike-enhanced agents in the same conversation.

Hey Product Hunt 👋 Tessa here from @Tabstack by Mozilla

Most web automation tools hand you a browser and leave the hard parts to you: hosting it, driving it, and paying for vision tokens on every screenshot. Automate flips that. You send a task in plain language plus a URL, we run the browser on our side, and you get finished output back in one streaming API call. Drop it into an agent or wire it into an app you already ship in a matter of a few minutes.

It can book a meeting, fill a multi-step form, or pull data from a page that only renders after you click around. The engine reads the page's accessibility tree instead of screenshots, so it spends 60 to 80% fewer tokens than screenshot-based agents. That's a different cost model once you're running this at scale.

Free to get started at tabstack.ai/browser-automation

If you're building agents or adding web actions to an app, I'd genuinely love to know: what's the first task you'd point it at? I'll be here all day answering everything. Thank you for taking a look 🙏

We're launchmaxxing @Tabstack by Mozilla on Product Hunt! Browser Automation is the 6th launch here, and it's the most ambitious one to date. No pressure.

S/O to @tessak22 and team for the great work. Looking forward to seeing what the community is building with it.

Get started for free: tabstack.ai/browser-automation

Tried it on a couple research queries and the cited multi-source output was solid. Nice that it returns clean Markdown instead of forcing me to parse raw HTML.

You had me at fewer tokens! 😁

Great product!

Congrats on the launch and good luck!

Super cool! Is it safe to use with authenticated workflows? What's the security model?

Not having to host the browser removes the exact part of web automation that always breaks in production. How are you handling sites with heavy bot detection, is that abstracted away or still on the developer side? Reading the accessibility tree instead of screenshots is a smart cost move too, that token math adds up fast at scale.

Mozilla shipping something this developer-focused and privacy-conscious feels like a nice return to form. Loving that robots.txt compliance and ephemeral processing are defaults, not afterthoughts.

How does the pricing scale if my agent is firing hundreds of these calls per hour, and is there a way to cap costs before things get out of hand?

the stateless-per-call design makes sense for reliability but I'm curious how it handles flows that need to stay logged in across steps - like a site where you need a session cookie from step one to do anything in step two. do you pass auth state back in yourself each call, or is there something built in for that

How does the ephemeral processing actually work in practice, like is there any retention window for debugging failed calls or is it truly gone the second the response lands?

How does the pricing actually work for the research calls versus the simpler Markdown or extraction endpoints, since those seem like pretty different workloads?

finally tried this and the schema extraction felt shockingly clean, called it for a few messy product pages and got structured JSON back without babysitting.

Curious how it handles sites that block headless browsers or rely heavily on client-side rendering since you mentioned no browser infra on my end.

Spent a few minutes poking around the schema extraction and it actually nailed a messy recipe page on the first try. The robots.txt compliance detail is a nice touch for anyone tired of sketchy scrapers.

How does this handle sites with heavy bot protection or JS-only content that needs real browser interaction, and is that tier priced differently than simple fetches?

how does the robots.txt compliance work when an agent needs data from a page that's blocked but technically accessible via the rendered DOM?

how does the robots.txt compliance actually work when an agent needs to interact with a page that blocks scraping, does the API just refuse or is there a way to get the structured data another way

How does it actually handle sites with heavy anti-bot protection or JavaScript-heavy SPAs that need real browser rendering under the hood?

Schema extraction in one call actually worked on a messy docs page, which was a nice surprise. The robots.txt compliance by default is a solid touch.

The accessibility-tree-over-screenshots call is the smart part - screenshot agents are the ones that quietly break the moment a layout shifts. First task I'd point it at: pulling structured data out of the messy 'contact us / booking' pages that never expose an API. That's exactly where my agents lose the thread today. Congrats on shipping.

I have some experience with workflow automation, so this caught my attention. Is it fair to think of Tabstack as browser automation powered by AI, rather than a traditional RPA workflow? I'd love to understand where the biggest differences are.

Wow, another great innovation. I hope this works both ways and makes it more standard to implement accessibility trees. A11y continues to be important in the agentic web!

That clears it up, thanks Tessa. Goal-driven re-plan is the right default for read tasks, but it makes retries scary for anything that writes. If a run already hit submit before it died, a fresh re-plan can submit again, and most web forms won't dedupe that for you. In our own agent loops we gate the side-effecting step behind an idempotency key so a second attempt no-ops, but that only holds if the target honors it. Any notion of marking a step do-once so a retry skips it?

Not sure that my feedback can be useful, because I`m not too deep in the topic. But I love homepade of your website - it is clear and has all information needed. Keeping instruction near the start button was a very smart decision.

Congrats on the launch, folks! Turning "give agents the web" into five clean endpoints instead of a black box is an interesting call.

Just a curious question: when an agent's task requires a page that robots.txt disallows, does the API fail with a clear signal to reroute, or is that boundary invisible until production?

Is this running remotely on another server? Seems really cool. How does things like Google auth work?

Hi Tessa, the fact that whatever I pull off the web stays mine is what makes this stand out to me. Anyone who has watched a scraper quietly break overnight will feel the relief here.

Hey Hunters! 👋

I'm excited to hunt Claude Sonnet 5 today.

Claude Sonnet 5 is Anthropic's most agentic Sonnet yet—able to plan, use tools like browsers and terminals, and complete complex tasks autonomously. It delivers major improvements in reasoning, coding, and knowledge work, with performance approaching Opus 4.8 at a lower cost.

Now available across all Claude apps for Free, Pro, Max, Team, and Enterprise users. What will you build with it?

Loving "baby Fabel" so far. Started to use it lasst night. Feels a s good as Opus 4.6 TBH. 🙏

A develper freind of mine is always comparing AI models for coding tasks. I am definitely sending this over because I know they will want to benchmark it.

The agentic framing is the interesting shift here, more than the benchmark bump. Curious about the guardrail side though - when it's chaining terminal and browser calls on its own, is there a built-in checkpoint before anything irreversible (deleting files, submitting a form, sending a message) or is that entirely left to whoever builds the wrapper app? That's the part that decides whether I'd actually trust it running unattended overnight.

How does Claude handle really long documents compared to other models, and is there a hard cap on context length or input size?

Used Claude to draft a tricky client email and it actually got the tone right on the first try, which surprised me.

Used it for a quick writing task and it kept the tone consistent without me having to repeat myself, which honestly surprised me.

Used it for a couple of writing tasks and the tone felt surprisingly steady, no weird over-eager cheerfulness. The thing I keep coming back to is how it actually remembers what I asked earlier in the chat.

I use Claude Code daily for my side project and the jump in agentic behavior is noticeable — it gets further into a task before needing me to step in. The coding improvements are real too. Curious how Sonnet 5 stacks up against Opus 4.8 on longer multi-file refactors, that's where I still feel the difference most.

the tone in claude's responses feels really considered, not just safe but actually tuned to match the weight of what you're asking. that's hard to pull off and it shows the team sweats the calibration.

The way Claude handles long, nuanced conversations without losing context really stands out. Feels like real craft went into the steering and tone control behind the scenes.

Finally got around to trying Claude for some coding help and it actually caught a subtle bug I missed, with a clear explanation of why it happened.

the line that got me is Sonnet basically creeping up on Opus 4.8 territory while costing way less, that's a wild place for the mid tier to sit. when it's driving a browser or terminal on its own, what's it actually doing to keep a long autonomous run from quietly drifting off the original task?

Curious how Claude handles really long documents compared to the usual token limits I'm used to. Can you drop in a 200 page PDF and have it pull out specific info accurately?

Honestly the tone feels way more natural than other assistants I've poked at, and it actually pushed back politely when my prompt was vague instead of just guessing. Made me trust the answer more.

Honestly impressed by how Claude handles longer context without losing the thread. Used it to summarize a messy research doc and it actually flagged ambiguities instead of guessing.

How does the pricing scale for heavier workloads, and are there any caps on context length or API rate limits I should watch out for at the higher tiers?

Working great for coordination tasks so far!

How does Claude handle really long documents compared to other models I've tried, and is there a way to feed it multiple files at once or do I have to paste everything in?

How does Claude handle really long documents compared to other assistants you've tried, and is there a hard cap on context length I should know about?

the way claude handles long context without losing nuance genuinely impresses me

I run Sonnet in long agent loops, so the thing I'm watching is tool-call stability: how many calls it chains before it drifts off the original plan. Older Sonnets would start second-guessing a decision they'd already committed to around call 15, which quietly derails an autonomous run. If Sonnet 5 holds the plan through a deep terminal-and-browser session, that's worth more to me than a few SWE-bench points. Anyone pushed it on long-horizon stability yet?

Hey all!

I'm Zach, one of the creators of Adam. Adam is an AI harness that integrates directly with your CAD. It reads your parts, understands the existing feature tree, and edits it for you agentically. We are now live as a copilot in Onshape and Fusion!

We are also very excited to hear that Fable 5 is coming back today! We have found this model to be a state of the art in agentic CAD & broader mechanical engineering tasks. We will keep you updated as we add it back into production today as our default model :)

@zach_dive Editing an existing feature tree instead of starting over sounds like a lifesaver. How does it hold up when the model is an absolute mess?

@zach_dive I've spent way too many late nights cleaning feature trees. Can this really take that pain away?

I've always felt that CAD has a sleep learning curve especially when making small design changes. Being able to describe what I want instaed of hurting through features sounds incredibly useful. Congrats on the launch!

Great launch. Mechanical design has so many repetitive tasks that AI can genuinely help with, and this feels focused on improving engineers' existing workflow rather than trying to replace it. best f luck with today's launch.

@zach_dive Honestly my impression is that engineering AI needs deep contextual understanding to be trusted. Understanding feature history and editing intelligently feels like an important move toward that future.

@zach_dive How's it doing with complicated parametric models? Those are usually where AI starts sweating.

A colleague of mine spends hours making repetitive CAD edits every week. I am definitely going to send this their way because it seems like something whey would appreciate.

This feels like a practical step for CAD automation. Most engineers I know care more about preserving feature trees than geometry from scartch, so this approach makes sense.

@zach_dive Appernetly everything looks perfect but I wonder that how Adam balances speed with preserving original design intent during larger iterative edits?

@zach_dive Be honest, how often does it get the edit right on the first try?

@zach_dive Does it play nicely with imorted files, or is that where things start falling apart?

I have seen AI generate CAD models before, but editing existing designs intelligently is a much harder problem. It looks like your team focused on solving the part that actually matters in day-to-day engineering

@zach_dive Does it ever point out a cleaner way to model something, or does it only do exactly what you ask?

Congrats! This feels like a “Cursor for CAD” moment. I’m curious about that after Adam makes an edit, how do you help engineers verify that the resulting model still preserves design intent, constraints, and manufacturability?

Congratulations on the launch! Does Adam learn from a company's existing CAD design standards over time, or does every project start from the same general model? Curious how customizable the workflow is.

Looks great for designers working under tight deadlines. Does it integrate smoothly with existing cad tools or work as a standalone layer?

Tried it on a Fusion model and the geometry referencing actually worked, which is more than I expected. The feature tree cleanup saved me some real time on a messy bracket assembly.

finally an ai that actually works inside my fusion workflow instead of dumping a screenshot back at me, the clean up feature tree trick saved me on a bracket design yesterday

Keeping everything editable is such a thoughtful choice for engineers who hate black-box tools, nice work building it natively into Fusion and Onshape rather than bolting on another tab.

Really love that the edits stay fully editable in the feature tree instead of getting flattened into dumb geometry. The decision to integrate natively inside Fusion and Onshape instead of pushing yet another window is exactly what mechanical engineers actually need.

Finally tried Adam in Fusion and was honestly surprised how well it understood my messy feature tree. Just told it to clean up the boss and it actually kept the dimensions editable, which is more than I can say for most AI tools I have poked at.

Does Adam run fully inside Fusion and Onshape without needing a separate window, or do I have to bounce back and forth to a web app?

been waiting for something like this inside Fusion, the prompt-based part editing feels surprisingly natural and the feature tree stays editable which is a big deal

Really nice touch keeping everything editable and tied to the actual feature tree instead of just spitting out a static STL, that's the part most AI CAD tools get wrong and it shows the team actually understands how engineers work in Fusion and Onshape.

Finally a CAD copilot that lives inside Fusion and keeps the feature tree editable, not some black box export. Cleaning up a messy tree with a single prompt felt almost too easy.

How does it handle complex assemblies where multiple parts interact, or is it mainly aimed at single-part edits right now?

How does Adam handle complex assemblies with lots of constraints, and does it keep parametric history intact when it edits features?

the Fable 5 as state of the art for agentic CAD claim caught my eye. when I point it at selected geometry and ask for an edit, does it reason through the feature tree so the history stays clean, or just bolt on stuff that breaks the second I tweak an upstream parameter?

Hi Product Hunt,
After getting experience from @Mailwarm, the warmup deliverability tool. @mailX by mailwarm the free email deliverability toolkit for humans and AI agents to check and fix your deliverability.

We decided to launch @MailAdept by mailwarm the email deliverability agency, so we can use all our experience to make sure you land in the inbox. Coming from the software industry we worked on service and pricing to adapt to the target and made it subscription based.

So basically for a flat monthly subscription you get our expert deliverability expert on your team :)

I hope you will like it

Congratulations 🎊

Can Mailwarm work with self-hosted mail servers?

Email is such a hard space to build in! Congrats for building such a cool product

The pitch makes sense but I'd want the pricing on the page before calling it a no brainer - there are free tools like Google Postmaster Tools and even Mailwarm's own toolkit that already cover authentication and blacklist checks. For a company sending under ~50k emails a month, what's the actual gap a subscription team closes that a decent marketing ops person plus those free tools doesn't?

Congrats on the launch team!

Congrats on the launch! 🎉 This hits close to home. This week alone, while following up by phone with leads I'd emailed, multiple people told me my messages went straight to spam. I had no idea until they said it out loud, which is exactly the problem: you don't find out until it's already cost you the conversation. Wish I'd had MailAdept in place beforehand, having AI agents plus real experts continuously monitoring health and inbox placement instead of finding out secondhand from a prospect is a genuinely different way to approach this. Excited to try it so I stop losing leads to a spam folder I can't see. Wishing you a great launch day!

Took a chance on this and the weekly reporting actually flagged a real SPF issue I'd been ignoring. The audit was surprisingly thorough for something that runs on autopilot.

Curious how the split actually works between your AI agents and the human experts, like which parts of the audit are fully automated and which still need a person in the loop? Want to know what I am actually getting for the subscription tier before I bring it to my team.

The daily monitoring plus weekly reports combo is genuinely useful, finally I can see why emails are landing in spam without digging through dashboards myself.

The weekly reports are surprisingly detailed and actually useful, not just vanity metrics. Pairing AI monitoring with human review feels like a smart middle ground.

Curious how this actually plays out in practice since most deliverability services are kind of hands off. Does the AI agent just flag stuff for a human to review, or can it directly push changes to things like SPF/DKIM records on my behalf?

The setup was painless and I noticed the weekly placement reports actually flagged a SPF misconfiguration I'd been chasing for months. Having both AI and a real person reviewing things feels like the right balance.

Congrats! Deliverability really is one of those things nobody on the team wants to own until it breaks. Curious how hands on you get when something drops, are you fixing the DNS and auth for the client or pointing them to it?

Deliverability being nobody's job is the hidden killer. Every founder I've talked to who runs cold email eventually finds out that "we have SPF and DKIM configured" doesn't mean their emails are landing anywhere useful.

Real setup for what it's worth, running 3 warmed domains, 9 mailboxes, mid-launch prep. What I keep learning the hard way:

1) Warmup networks warm you up to other warmup networks. Auth clean, Mail-Tester 10/10, no blacklists, 57% Gmail inbox on first real test. The warmup graph and the real Gmail graph are not the same graph, and no dashboard tells you that.

2) The metrics that predict inbox placement don't show up until they're already broken. By the time reputation drops, you've already sent to a batch you'd like back.

3) The move that changed the most for me was reducing volume even after warmup looked "done." Sending fewer, better-targeted emails from a warm domain outperforms sending more from a "fully warmed" one.

Honest question, what's your take on the tradeoff between adding a deliverability service like MailAdept vs. just sending less volume? I'm trying to figure out if the fix I've been reaching for (throttle everything) is a real fix or a compensation for infrastructure I should be paying someone else to own.

The weekly inbox placement reports actually showed changes I could measure in our open rates, which is more than I expected from a "set it and forget it" tool.

Deliverability genuinely needs an owner, the framing makes sense :) But picking up Curious Kitty's thread: the answers here list what you monitor (DKIM, blacklists, metrics), not how you know the placement number is real.

Gmail and Outlook never tell you if a real recipient hit Primary, Promotions or Spam. So placement usually comes from seed lists, the least representative inboxes there are: they never open, reply, or rescue you from spam. You can read "95% inbox" on the panel and still land in Promotions for the humans who matter.

So: what's actually behind the daily signal, seed panels, Postmaster, real engagement telemetry? And when the panel says green but the leads say spam (like Anas described above), which do you trust?

Congrats on the launch! ;)

Congratulations on the launch!

How does the AI actually decide when to escalate something to a human expert versus handling it on its own?

Curious how this works with custom transactional sending setups, especially if we already have our own DKIM/SPF records in place from years ago. Would the audit just confirm whats working or actually help us rethink the whole infrastructure setup?

How does the pricing actually scale as the list grows, and does the weekly reporting give concrete next steps or just charts?

Curious about the AI side, does it proactively recommend infrastructure changes (SPF, DKIM, DMARC, domain reputation, etc.), or does it also implement fixes?

We live in an interesting world. I wonder how long it will be before this turns into a battle between AI agents writing and sending emails and AI agents setting increasingly strict inbound filters - with absolutely no human involved in the process. Or are we already there?

the "AI agents plus human experts" combo is the right call for something like deliverability. pure automation is risky here because ISPs change their spam filtering logic constantly and a model trained on old patterns could confidently give bad advice. curious how the handoff works though, does the agent flag issues for human review automatically or do the experts just spot check periodically?

This is pretty amazing. So do you only provide consulting services?

can MailAdept identify sender reputation trends over time? does it help predict future deliverability risks? that would be incredibly useful.

Thats a cool product, whats is the pricing pf the monitoring ?

Love the direction here! Building apps should be about bringing ideas to life, not getting stuck in repetitive setup and boilerplate. Modelence looks like a promising step toward making app creation much faster and more accessible. Congrats on the launch, and best of luck! 🚀

Can the same prompt really maintain feature parity between web and mobile? That's impressive if it works consistently

Congrats on the launch

Congrats on the launch! Are there any tips-and-tricks on how to create/maintain the strict design system of the app, how to export/share it with web, or how your tool manages it?

been following since the web app builder launch and the pace here is great! congrats, team! domain experts who arent full devs are exactly the right people to aim at, most of them have hit the prototype ceiling 10x over. excited to see whats next on mobile 🚀

Got a basic CRUD app running in about ten minutes, and actually being able to poke at the generated code after is the part that sold me.

Been building a real app on Modelence, a World Cup pool with live scores, a leaderboard, and bracket predictions, and it holds up as a production app, not a prototype.

Two things stood out. I built the web version first, and the mobile app came off the same codebase and backend, so auth and every query just worked across both with no rebuilding anything twice. And since the backend, deployment, and monitoring are handled for you, I could stay on the product instead of wiring up infrastructure. It's still real code on an open framework too, so I can open it and extend by hand when I want.

I'm not a developer and still got to a real web and mobile app fast. Congrats on the mobile launch, excited to see where it goes.

Excited for the mobile app functionality. Been using Claude Code but the idea of creating my own mobile apps is awesome. Congrats Aram and Eduard! ~James

Looks very cool! Will have to give this a try. Great that the code is fully available and not hidden.

Scaffolded a quick side project over the weekend and the auth plus database wiring came through on the first try, which saved me a ton of setup time. The generated code was actually readable enough to tweak without fighting it.

code ownership is what sold me, being able to inspect and edit after generation instead of being locked into a black box

How much control do I actually have over the generated code if I want to swap out the auth provider later?

Congrats on the launch! are the mobile apps built natively (Swift/Java) or use React Native?

The Expo choice is smart, that's the fastest path to real iOS and Android from one codebase. The question web builders never have to answer but mobile ones do: where does the wall hit at ship time? Getting to a running app in Expo Go is the easy part, getting through signing, provisioning profiles, and App Store review is where most no-code mobile tools quietly hand you back a raw project. Does Modelence take you through EAS build and store submission, or stop at the code?

Sharing one codebase and backend between web and mobile from a single prompt is the part that would actually save time, most "AI app builder" mobile support I've seen is really a wrapped webview. Since it's on Expo, does the builder handle the native module gaps that Expo doesn't cover out of the box, and can it get you to a signed build ready for TestFlight/Play internal testing, or does that packaging step stay manual?

Nice! How does this fit into an existing project, or is it mainly designed for building apps from scratch? Congrats and good luck on the launch!

Built a small side project in like 10 minutes and was honestly surprised the auth and db hooks just worked without me babysitting them. Code was clean enough to actually tweak afterward.

Love that it gives you the code instead of hiding it behind a black box, that's a really thoughtful choice for a builder like this.

How does the generated code actually work under the hood - do I get a full repo I can self-host anywhere, or am I locked into running it on your infra?

How does the generated code stay maintainable when you need to add something the prompt didn't anticipate, do you end up rewriting large parts of it?

Love that the generated code is actually inspectable and editable instead of trapping you in a black box, that ownership angle feels rare in this space.

the fact that you actually own the generated code instead of being trapped in some walled garden is such a rare move for this category of tools, really appreciate that you made that the default rather than an upsell

Spun up a quick project to test it and the auth and database were already wired together when the build finished. Nice surprise that I could actually poke around the generated code instead of it being a black box.

The generated code actually looked like something I'd write myself, not a mess I'd need to rewrite from scratch. Deploying from the prompt was honestly the part that surprised me most.

Pulled it up and was surprised the auth and database bits were already wired together, no extra setup needed. Editing the generated code actually felt like normal code rather than some locked-in template.

How does the generated code handle custom domain setup and ongoing maintenance when you want to swap out the built-in auth for something like Clerk or Auth0 later?

Love the structure of your website - it made me interested even not being the developer. "Build real apps, not prototypes" is a strong positioning line!
I'm curious though, do you find that non-technical founders also try to use Modelence, or is it really purely a developer tool?"

Appreciate the straight answer, most tools in this space quietly pretend the last mile doesn't exist. EAS getting you to a real signed build is the bulk of the pain gone. The one thing I'd keep watching for AI-generated apps is App Store review itself: Apple's 4.2 minimum-functionality rule tends to flag apps that read as too templated or thin. Does the generated output vary enough structurally to clear that, or is dodging it mostly on the person doing the customizing?

One of the most interesting launches today! When one movement fans out across three accounts and leg two clears but leg three bounces, do you guys unwind the cleared legs or you hand the agent an almost-done state to reconcile?

This is exactly what I was looking for. Even guys from MFM podcast mentioned this idea a month or so ago. Congrats guys, this is great!

This looks great, congrats! Is this live already, or is this a coming soon launch?

Love this! Go go go Sequence ♥️

Cool!
Best of luck to you! 🔥

@gilad_uziely Nice! I was planning to built family financial planner/router for my kids (that keeps asking more money for various reason) and got stuck. I'll give it a try and build Claude agent + Sequence and see how it goes, stay tuned!

Really love what you're building! Couple of questions:

1. Does the API work with any vibe-coding platform, or only specific ones?

2. What have you done to keep the flows secure?
   
   
   

Super cool product! What stops an agent from moving money it's not supposed to, is there a human approval step anywhere?

the concept it's crazy, but I honestly wouldn't give access to an ai to handle my money, but the products seems amazing, good job.

I've been using Sequence for just under a year now, and it's significantly improved my financial literacy and visibility! I can tell the team has been putting in a lot of hard work, good to see you guys finally launching on Product Hunt, congrats!

Congrats on the launch @gilad_uziely and team! I love the idea of agents actually doing things with money! What banks and account types does it actually work with?

Amazing work @gilad_uziely and team, super impressed!

Sequence user here. Big fan, congrats on the launch! Being able to actually automate how my money moves just like any other workflow has been really cool, and the ability to just hand it off to Claude is a game changer.

Still waiting for that iOS app though :)

Congrats on the launch, folks!

Just curious, for the approval-threshold flow, does the audit trail capture the agent's reasoning for the transfer (the prompt/context that led to it), or just the transaction itself? Feels like when something does get flagged for human review, having the "why" alongside the "what" would make that review 10x faster.

Neat execution layer. How do you handle reconciliation when an agent triggers a movement across multiple accounts simultaneously?

Very cool - was just looking at this for my YouTube channel, and thought the workflow for agent cards concept is cool, maybe like Ramp but for agent to agent or agent to product purchases.

Quick question - are there backstops I can put so when an agent wants make a purchase it blocks it due to constraints? Like if this then not this type vibe? Will yield great determinism to non-deterministic workflows

That async-plus-job-ID shape is the right call, and the idempotency token is the bit I'd have asked for next. The failure I keep hitting building agents: the process dies right after firing a movement but before it sees the response, and on restart it re-issues the same call. Without a caller-supplied idempotency key that's a silent double-send. Glad yours is a first-class field and not a header afterthought.

spending limits and audit trails are the right instinct but the part i'd want to poke at is the failure mode where the agent's reasoning is fine on paper but it moves money based on a hallucinated balance or a bad read of an invoice. is the audit trail just a log after the fact, or is there a human approval step for anything above the scoped limit before it actually executes

This is cool! Is this only for developers, or can non-technical people use it too?

The security model is more interesting than the AI angle. Scoped keys plus server-side limits sounds much closer to how enterprises would actually approve agentic payments.

The scoped-keys-plus-server-side-limits part is the bit that actually matters here, and it's easy to underrate. I build agent tooling and prompt-level guardrails always leak eventually. Tell an agent 'never move more than $500' and under the wrong instruction chain it will cheerfully try anyway. The only thing that holds is a limit the agent literally can't see or edit. Question for @gilad_uziely: are the limits scoped per-key or per session, and can a compromised agent widen its own scope?

Putting the spend limits in the key server-side instead of in the prompt is the right call — the scoped-key answer above is the only thing that actually holds when an agent's reasoning goes sideways. The operator edge case I'd want pinned before wiring an agent to live money is retries: if an agent fires a transfer, times out, then retries, is there an idempotency key so it doesn't double-send? And for an in-limit but wrong transfer, is there any reversal/clawback window, or is it final on execution?

Finally a way to let my Claude agent actually move money without me hovering over it. The scoped keys and spending limits feel thoughtfully designed.

how does the auth model actually work in practice, like can my agent move money between two banks I own without me re-approving each transfer or is there a manual confirm step every time?

finally a way to stop babysitting my bots every time they touch a card. the scoped keys and audit trail actually feel like they were built by someone who got burned before.

The scoped keys and server-side limits make this feel more realistic than asking an agent to please behave around money. Approved invoice payments, vendor reimbursements, and tax-bucket transfers seem like narrow first use cases where audit trails can stay clean. Which workflow are you seeing customers most comfortable handing to an agent first?

finally got my cursor agent to actually move money between accounts, the scoped keys and spending limits make it feel way safer than i expected

Scoping each API key to specific accounts and limits feels like the right move for letting agents touch real money, and the audit trail is a nice touch. Honestly impressed it just plugged into my n8n flow with no fuss.

We built Mark because the existing marketing options were bad.

When we launched our own product and tried to go to market, everything about it was complicated. Marketing is fractured across SEO, content, outbound, social, and paid ads, and the tooling is so fragmented you practically need a go-to-market engineer just to wire a dozen subscriptions together. The alternative was an agency: $10K+ a month, and a lot of weekly meetings that eat up time.

So we built the marketing employee we wished we could hire. We’ve used Mark to automate large parts of Airtop's own marketing, including our Google Ads. Now we want to give him to everybody.

Most marketing tools in this space fail in one of three ways:

❌ Chatbots that ideate, then leave you to do all the actual work.

❌ Automation platforms that hand you building blocks, a dozen integrations to wire up, and zero marketing expertise.

❌ LLM-based agents that are unreliable and cost a fortune to run at scale.

Meet Mark 🚀

🔷 He researches your company deeply, crafts a personalized go-to-market plan, then builds web agents to execute it: SEO, lead generation, social, even paid ads.

🔷 Batteries included. Waterfall contact databases, email verification, enrichment, LinkedIn intelligence, are built in, so you can cancel your other subscriptions. Mark also has access to his own web browser: he can log into websites, fill out forms, and post on social media.

🔷 Built with training from real experts. Talking with Mark is like talking with a highly knowledgeable marketing consultant.

🔷 10x faster and 10-100x cheaper to run than LLM-based solutions. Mark uses intelligence to build reliable agents, then compiles them into executable code, like traditional software.

Who is this for?

Founders, lean teams, and solo marketers who don’t have the time, budget, or patience for a traditional marketing agency or complicated marketing automation tools.

🔗 Get started today

Try Mark free at airtop.ai/mark. Use the code MARKPH26 for one free month of Airtop’s Starter plan, which includes a 14 day trial of Mark.

Have a chat with Mark about your business, and see how he can take the pain out of going to market.

We are here all day. Ask us anything!

The demo site where it just logs in and pulls data on its own is wild. Love that you kept the interface to plain words instead of piling on dashboards.

Tried having it grab some shipping updates from my carrier portal and it actually logged in and pulled the info without a hiccup. The plain-English setup feels really natural.

this is genuinely impressive. told it to grab flight prices from a few sites and it actually logged in, navigated, and pulled clean data back. setup took maybe two minutes.

the way it turns plain english into actual browsing tasks feels like magic. loving the clean setup and how it just gets out of your way.

I tried it to pull pricing data from a few competitor sites and it worked surprisingly well without me touching a single API. The plain English framing is genuinely useful, though I did have to nudge it on captchas. Solid first impression.

Tried it on a couple of sites and it actually logged in and pulled the data I asked for, which surprised me for a no setup tool. Felt more reliable than other browser agents I've poked at.

Tried it for scraping some old vendor portals and it actually handled the login flow without me babysitting it, which honestly caught me off guard. Curious to see how it holds up on trickier captchas.

I used the early version of Mark to do some seriously cool stuff. My personal use case is building AI ops to make a small team of marketers' lives easier, and we're big fans.

I may be biased because I've been burned by agencies before, having to wait 6-12 months for results, not doing a good job with product stuff, and having little impact on priority SEO—focusing instead on improving 50-100-rank keywords.

Not going to reveal too many secrets but we were able to turn that around with Mark. Most of our automatable processes are assisted by Mark now, and we've brought in-house what would traditionally be considered agency work, seeing a significant increase in our tracked metrics while spending much less.

"no APIs, just words" is a strong claim for browser agents specifically because most sites don't have an API to begin with. that's the actual gap browser automation fills, the long tail of internal tools and dashboards that were never built with integration in mind. how does it handle sites with heavy bot detection though? logging in and browsing like a human is exactly the pattern most anti-bot systems are tuned to catch.

The GTM plan is the part that demos well, but generating a plan is the easy 20%. The thing I'd want to know building this kind of agent: does Mark close the loop on what actually converted, weeks later and through noisy attribution, and revise? Or is it generate-once? A plan a solo marketer can't measure against gets abandoned by week two.

I tried Mark (beta), and it put together a really solid go-to-market plan for me. The recommendations were practical and well thought out. Looking forward to seeing how it evolves. Congrats on the launch!

Finally gave it a real test by asking it to grab shipping rates from a courier site and it just logged in and pulled the data without me touching anything. Genuinely surprised how well it handled the login step.

Automating outbound and Google Ads straight from a website scrape is the part I'd watch closely - if Mark's GTM read of the business is slightly off, you're not just wasting time, you're burning ad spend and sending outbound copy that misrepresents what the company does. Is there a review step before Mark actually starts spending or emailing on your behalf, or does it go straight from plan to live campaign?

Got it, so it's steer-at-build-time. The thing I keep bumping into: declaring upfront which steps stay LLM-validated assumes I already know where the judgment gets hard, but the is-this-a-real-lead call goes wrong on the ambiguous 5% I can't enumerate in advance. What I'd really want is a step that re-checks itself at runtime when its own confidence drops, not a static flag set at build. Is that on the roadmap, or is build-time steering the model you're committed to?

Fair, as long as the builder calls that right. The step I'd want to override is the judgment one, like is-this-reply-a-real-lead. Your monitoring layer confirms a step completed, but a classifier can complete perfectly cleanly and still be wrong, and compiling it hides that failure mode. Can the author pin a specific step to stay LLM-evaluated on every run instead of letting it get compiled down to fixed code?

The Google Ads integration looks really cool! Google Ads has a TERRIBLE interface so it would be nice to just be able to prompt it SO uwu

Compiling intent into code is the right instinct, we landed in the same place: re-deriving the same plan with an LLM on every run is what kills reliability. Where it got hard for us was the genuinely non-deterministic steps, like 'is this reply a real lead or a bounce', you can't compile the judgment out. So the interesting line is compiled-vs-LLM: does Mark let the author pin certain steps as always-LLM, or does the compiler decide that itself?

the part that stands out to me is compiling into deterministic code instead of running an LLM call on every step. that's the actual fix for the reliability problem most agent tools have, cost aside. curious how it handles a site that changes its layout after the automation was compiled, does it silently break or re-detect and recompile

This looks super useful for automation workflows. How reliable is it when you scale multiple browser tasks at the same time?

How does it handle sites that require two-factor authentication or have aggressive bot detection? Curious how reliable it is in practice on those kinds of tricky logins.

How does it handle sites with heavy bot protection or CAPTCHAs that block most automation tools?

How does it handle sites with strict bot detection or CAPTCHAs when the agent tries to log in and grab data?

The "chatbots that ideate then leave you with all the work" line is exactly why I stopped trying to use AI for marketing planning early on. Getting a strategy back that reads well but has no path to execution is worse than having no help at all, because now I feel obligated to try it before admitting it was theater.

The compile-to-deterministic-code angle is where this gets interesting. Most agent frameworks I've seen have the same flaw as the strategy chatbots, they generate a plan every run, which means the plan drifts even when the task hasn't. Compiling once and re-running the compiled artifact is the pattern I keep wishing existed. Curious how you handle the case where the underlying page/site changes and the compiled agent breaks, do you re-compile on failure, or does Mark flag it and ask?

Also honest question, for someone running solo who already has a rough GTM shape they trust, does Mark benefit them, or is the biggest value for people who need help figuring out the plan itself? Trying to figure out if I'd get more value from the planning side or the execution side.

Congrats on the 4th launch :) The line I keep circling is "compiles every automation into deterministic code", it's the real bet, and where I'd push.

Compiled code runs cheap and reliable, agreed, but it freezes an assumption about a page you don't control. LinkedIn reshapes its DOM constantly. An LLM agent re-reads the page and adapts; a compiled one keeps doing exactly what it was compiled to do, right until a redesign makes it fill the wrong field with no error thrown.

So: when a site changes under a compiled agent, how does Mark notice (silent no-ops don't crash), and does it recompile itself or page a human? The happy path isn't the test, the silent drift is.

Congrats again!

The compile-agents-into-executable-code approach instead of keeping an LLM in the loop is what makes the reliability and cost claim believable. My setup question is about the accounts Mark logs into: when he posts to social or pulls LinkedIn data, where do those sessions/credentials actually live, on Airtop's hosted browsers server-side, or something scoped per user? And when a site changes its flow and a compiled agent breaks, does Mark detect the failure and auto-recompile, or do I have to trigger a rebuild?

How does it handle sites with heavy bot protection or CAPTCHAs, like LinkedIn or banking portals? Curious if that breaks the "just describe it" promise pretty quickly.

Looks cool guys, great idea. What are your policies on data handling and encryption, data privacy and training? Is data encrypted at rest and in transit? Would like to review your privacy and data handling procedures.

Hey folks! I'm Jordan from Airtop. Feel free to ask me questions about Mark or how the Airtop platform builds compiled agents <3

Interesting idea. Does Mark let you adjust targeting criteria before the agents actually go live?

Hey PH fam 👋

Video creation has always meant stitching five tools together.

A script model here, a text-to-image model there, an image-to-video tool, a separate lip-sync app, a voice generator.

Each one its own contract, its own learning curve, its own headache.

Now Google's latest offering Gemini Omni Flash collapses all of that into one model. It's the first release in Google's new Omni family, and it does something most video models can't: it actually holds a conversation with you while you edit. You don't regenerate from scratch every time you want a tweak. You just talk to it.

How it works:

→ Feed it text, images, or short video clips as references

→ It generates a clip grounded in Gemini's real-world knowledge (history, biology, narrative logic, all of it)

→ Ask for changes in plain English: "make the lighting warmer," "swap the product," "extend the camera pan"

→ It remembers the last few turns, so your edits build instead of starting over

Why it's worth your attention:

→ Priced at $0.10 per second of 720p output, matching Veo 3.1 Fast

→ Launched at #1 on LMArena's Text-to-Video Arena

→ Every clip carries SynthID watermarking and C2PA credentials baked in, so provenance isn't an afterthought

→ Pairs naturally with Nano Banana 2 Lite: generate a still image, then animate it straight into video

What strikes me most isn't the generation quality, it's the editing model.

Most AI video tools still treat you like a one-shot prompt engineer. This treats you like a director who gets to say "no, try that again, but..."

Curious what you'd build first: a product explainer, a localized training video, or something nobody's tried yet?

the conversational editing on video is such a smart move, makes iterating on outputs feel way less clunky than re-prompting from scratch

how does the conversational editing actually track changes across longer videos? like if i tweak a scene midway does it regenerate everything after or just hold the rest steady

The conversational editing part is what I'd poke at first. At $0.10 per second of output, if I generate a 20-second clip and then say make the second shot slower, am I re-rendering and paying for the full 20 seconds each turn, or does it diff against the previous render? Iterative editing is where costs quietly balloon on these, so whether an edit re-bills the whole clip really changes the economics of building on it.

Looks interesting! will try it out!

The SynthID/C2PA point is what caught my eye more than the pricing. Once you go a few conversational edit turns deep on the same clip, does the credential chain track the full edit history back to the original generation, or does each new turn just stamp a fresh credential with no link to what it started from? For anything used in a context where provenance actually matters, that distinction seems like it would decide whether this is usable at all.

finally got around to testing this in AI Studio and the conversational editing actually feels fluid, not the usual clunky back and forth. surprised how well it held consistency across a few video iterations

Curious how the conversation editing handles continuity across longer clips, do the earlier frames stay consistent when you ask for revisions halfway through a generated video?

The conversational editing from a video input feels really natural, you can nudge a scene and it actually listens. Pricing matches Veo 3.1 Fast so it slots in nicely for quick iterations.

How well does it hold up when I ask it to swap out a single object across multiple clips while keeping the lighting consistent? Curious if that kind of multi-shot edit actually feels coherent or if it still breaks halfway through.

Pulled it into AI Studio yesterday and the conversational editing actually feels natural, like it understood I wanted to swap the background without rebuilding the whole clip. Pricing matching Veo 3.1 Fast makes it easy to justify experimenting more.

Picked it up yesterday and was honestly surprised how natural the conversational editing feels, you can tweak a scene by just asking. Video quality holds up well for the price too.

Hey Product Hunt, It's Dalena, co-founder and CEO of Fuser. Thanks to @chrismessina for hunting us. 💌
We're back with Fuser Apps! Fuser Apps is our most ambitious and powerful release to date. Your canvas now holds all the context needed to become the source material for your next application. Publishing an app is as easy as hitting "publish" and your app can hold modular databases and become multiplayer instantly.

Since I was a teenager I've been carrying around ideas. Films, platforms, things I wanted to exist that didn't yet. Believing an idea was worth the time, the urgency, the effort to make real was always the hard part. And having the means to do it.

Fuser Apps is our attempt to close that gap. Make whatever is in your head before you forget it. Ideas are perishable. Wait too long and they become another note, screenshot, or bookmark. So move while the idea still knows what it wants to be. Make the small thing. The weird thing. The thing that only matters to five people.

If it found you, maybe it's yours to make.

Happy creating with apps in Fuser!

Free app generations for a month, and all PH users get 20% off first 3 months.

There's a particular kind of joy in watching something you helped work on start to take on a life of its own :)

With Fuser Apps, I've already started to see creators, friends, and artists spin up new working apps in real time: multiplayer experiments, collaborative tools, games, generative art, weird little interactive toys, useful things, silly things, things that don't fit any category at all.

And honestly, we're still only scratching the surface. There are features here doing quiet, powerful work that people are just starting to discover, like easily pulling aspects of one app directly into another and seeing it come alive in an entirely new context. That kind of fluidity, where ideas move within and between projects instead of staying locked inside them, feels like the start of something genuinely new.

As a visual thinker, the canvas is such an intuitive way for me to create compared with other approaches to development. It's not a blank command line or chat window, it's a space where ideas, iterations, and media are visible and relational, where creating means shaping connections rather than issuing instructions. That shift changes what's possible.

Deeply proud of this team, and even more excited to see what people make with this.

Thanks @chrismessina for hunting us!

Hi PH! Hirad here, co-founder and CTO.

We've all got a graveyard of ideas that never left the deck. An interactive concept that never got past the render. A microsite the studio scoped and quietly shelved. The experiential thing the whole room loved in the pitch, killed by a build timeline nobody could afford.

The ideas were never the problem. The distance between "this should exist" and "this is live and someone can actually touch it" was — everything between the concept and the build, where the good ones quietly die.

Fuser Apps is us closing that distance. You describe the thing you wish existed and it goes live — a real link you can put in front of a client or a room, from your phone, before the idea gets cold.

We've put more real (and more gloriously weird) little things into people's hands in the past week than in the years before it, because the cost of actually making one dropped to basically nothing.

Go make something and put it in front of someone. Then come break it and tell us what's missing — we're here all day.

P.S. @chrismessina hunted us — thank you, truly.

Fuser Apps has been an incredible step forward for our workflows. With apps, I find myself able to iterate quickly and with close proximity to other apps or nodes that live on my canvas, without needing to leave my Fuser project. It's been the quickest way to prototype all the web components I've been dreaming about, can't wait to build more 😎

Everything we were already making on the canvas — images, references, mockups, 3D, video, sound — can now feed directly into a working app, website, prototype, game, anything.  For creatives, designers, and tinkerers, the whole pipeline just collapsed into one surface. It's been a game changer for our internal creative team already, and I am so excited to share this with the world!

This feels like a major step forward.The idea that assets, references, and data can become part of an app’s behavior opens up some really exciting possibilities for artists, designers, and creative technologists. Excited to see what the community builds over the next month. 💙

I've had a wonderful time watching friends and coworkers make apps and test out-there experiments in Fuser. When I use the app and other canvas features I'm taken aback by how quietly powerful and meticulously thought-through the tools and capabilities are. It's clear that Fuser is a tool made by creatives, for creatives.

The app feature is exciting as I've been seeing my ideas come to life through interactivity with ease, feels like a big unlock for new kinds of making!

I’ve been watching Fuser quietly become the canvas creative people actually keep open — the place where images, video, sound, and 3D live side by side instead of scattered across ten tabs. So I’ve been waiting for this one!

Fuser Apps is the part that clicks everything into place: the stuff on your canvas isn’t just output anymore. Your references, your generations, your media become live inputs an app can read, respond to, and evolve from. You prompt, generate, edit, and ship — (no code needed) — and are live in minutes.

Most “vibecode an app” tools hand you a blank text box. Fuser hands you a canvas you’ve already filled with real creative material, then lets you turn it into something you can use. That’s a different thing entirely, and it’s the direction I’ve wanted this whole space to go.

Congrats to @dalenaxtran, @hiradsab, and the team.

App generations are free on fuser.studio for the next month — go make something and see what the canvas does when it starts talking back. 💙

Being able to mix images, video, sound and 3D on one canvas and turn it straight into a live app is a different pitch than the usual vibe coding tools. Curious about style consistency - if I generate a character in one node and reuse it across a video node and a game asset node, does it stay recognizably the same character, or do you end up reprompting each modality separately to match it up?

Congratulations to Fuser for shipping this new feature. Been using this platform and love the Fuser Apps!

Congrats on the launch @dalenaxtran and @hiradsab !

Excited to see what users will build with Fuser Apps :)

Love that you went with a node-based canvas instead of hiding everything behind a chat box for creative work, seeing and controlling the pipeline matters. Credits never expiring is a nice trust move too, most tools quietly bank on you forgetting them.

Curious how you handle versioning when a team iterates on the same canvas? Congrats on the launch 🚀

Spent a few minutes dragging nodes around and connecting different models together, and it felt way more intuitive than other node tools I've poked at. Really liked how the canvas stayed smooth even when I started stacking iterations on top of each other.

Finally tried fusing ideas across text and image models without juggling tabs, and the node view makes it so much easier to see what feeds into what. The orchestration layer actually feels useful, not just a buzzword.

This is the piece that clicks for me. Apps built directly on the canvas mean the creative work doesn't end when the generation does and the canvas itself becomes the source. Now that workflow can be a living, shareable thing. That's not a small feature, it's a new stage in the process that didn't exist before: you're not just producing an asset, you're producing something someone else can open, edit, use, pass on etc.

These apps are tailored to what's actually built on the canvas, they occupy this new layer between the creator and the outcome, between process and result. That layer is what's been missing from most creative AI tooling. Everyone's solved "generate more, generate faster," but almost no one has solved "turn what I made into something that lives and travels on its own."

This feels foundational rather than incremental, not just for AI in design, but for where design as a discipline is heading across every industry that touches a screen.

Super excited to see where this goes, so proud of that team!

How does Fuser handle version control when iterating across multiple models and modalities, and is there a way to roll back to a previous node configuration without losing the downstream outputs?

The canvas-as-source-material idea is the interesting leap here. What I'd want to know is what happens to the model nodes once you hit publish. At design time a slow or flaky model call is fine because you're sitting there iterating, but in a live app that same node sits on an end user's hot path. Does a published app cache node outputs or fall back when a model times out or returns junk, or does the user just see the raw failure? That's usually where it-worked-on-my-canvas breaks.

I'd love reusable component libraries that can be shared across multiple Fuser projects.

the visual workflow feels much more approachable than bouncing between prompts and code editors.

I love that this isn't limited to websites. Apps, games, media, and interactive experiences all in one place is exciting.

Can teams collaborate on the same canvas simultaneously, similar to Figma or multiplayer whiteboards?

How does pricing work for integrating multiple model providers, and is there a cap on how many nodes you can run per workspace?

Curious how pricing scales as you plug in more models and workflows, especially for folks running heavier creative experiments on top of it.

Curious how this plays with models that aren't behind an API—can I drop in local checkpoints from my own machine, or is it strictly tied to hosted providers for everything?

How does pricing work as you scale up across multiple models and modalities? Curious if I'm paying per node or per output, especially since I'd be running a lot of experiments at once.

Spent a few minutes dragging nodes around and genuinely liked how fast it felt to wire up different models side by side. The canvas stays smooth even when you stack a dozen connections, which is rare.

Love how the node canvas just keeps going—no clutter, everything stays readable even when I'm juggling a bunch of models. Feels like it finally gets out of the way when I want to experiment.

The node-based canvas feels incredibly fluid, especially how it handles dragging connections between different model types without that clunky snap-to-grid behavior most tools force on you. Nice execution.

How does Fuser handle version control when you are iterating across multiple models and modalities at the same time, is it built in or do I need to wire that up myself?

Curious how this handles versioning when you branch a workflow a few times and want to compare the outputs side by side, does it track that history automatically or is that on me to manage?

Curious how many tokens a full science experiment would take to run on Claude Science.... 🔬👩🏻‍🔬

finally a desktop version, super handy for when I'm bouncing between docs and tabs. voice mode feels snappy and the dark theme actually respects my system settings.

Does the desktop version sync conversations with the web and mobile apps seamlessly, or do I need to manage separate histories on each device?

Finally downloaded it on my laptop and the setup took like thirty seconds, super painless. Nice having Claude right there on my dock without opening a browser tab every time.

Finally a desktop app that doesn't try to do too much. The clean install flow and how quickly it pinned to my dock made me actually want to use it.

The desktop app feels really polished, especially how quickly it picks up context from whatever I am working on. Nice execution on making something that just feels native to the OS.

Does this sync my chat history between desktop and mobile, or do I have to start fresh every time I switch devices?

Does the desktop app let me pick up a chat from my phone without losing the thread, or are those treated as separate sessions?

Finally have Claude right on my desktop, super handy for quick questions without opening a browser tab.

finally gave the desktop app a try and the keyboard shortcut to summon claude right in front of whatever im working on is genuinely useful, didnt expect to use it this much

The native desktop feel is refreshingly smooth, especially how quickly it launches and sits ready without feeling like a wrapped web app. Nice execution on making it feel like a first-class citizen on the desktop.

How does the desktop version actually sync with the web version in practice? I bounce between my laptop and phone constantly and want to know if conversations carry over seamlessly or if there are any gotchas.

How does the desktop version sync conversations across my phone and laptop in real time?

how does the desktop version compare to using claude in the browser, anything different under the hood or just a wrapper around the same thing

Unexpected (for me) direction from Anthropic but I'm excited to play around with it. As an European who never found a good alternative to OpenEvidence, I hope it can help with that (although it's obviously not the main intended use)

This is a really interesting direction for Claude.

For research workflows, the biggest value seems to be not just getting an answer, but being able to trace every step of the analysis and reproduce the reasoning later.

Curious how Claude Science handles larger datasets and long-running experiments. Does it keep an audit trail of each step, tool call, and assumption so researchers can review or reproduce the workflow?

Love the direction and already am a Claude desktop user! I'm curious, how does Claude Science balance long-running analyses with context limits, especially when working with large datasets and multi-step experiments? Also, how does pricing scale for researchers running larger workloads?

Hey Product Hunt✌🏻

We've spent half a decade developing an amazing trackpad ring that allows you to inertial scrolling in two directions & today we're adding voice!

Making this trackpad work took many years. We tried capacitive touch first, but we found the surface area is too small for responsive vertical and horizontal scrolling. We then moved to optical touch but false positive detection was not great. We ended up combining both capacitive and optical to get the best of both worlds, which we patented along with other novel context switching features we'll announce later (stay tuned!).
We also intentionally decided to focus on interactions and leave health features out to be able to provide the best interaction experience possible. The result of these choices is what sets it apart. It is not a health tracker, nor is it voice-only. It enables both voice and very expressive touch interactions that are unique to OASIS at the moment.

OASIS can eventually be used with many platforms like iOS, MacOS, and VisionOS. But today we're focused on launching our MacOS experience integrated with Wispr Flow. We met the Wispr guys in the middle of last year and it was clear they had figure out voice in a way nobody else had. Now that more people are using the modality, our device can help them keep using this modality in situations where they otherwise couldn't like quiet offices, coffee shops, and libraries.

Stay tuned for our take on mobile and cross-platform context switching in the future.

All the best,

Ricky

The whisper capture actually works in a quiet room without sounding robotic, which I was not expecting. Trackpad editing on the finger is a neat trick for quick fixes without breaking flow.

Finally a ring that gets dictation right, the whisper capture feels almost magical in a quiet room.

how well does the whisper capture actually hold up in a moderately noisy coffee shop without accidentally picking up nearby conversations

How well does the voice pickup actually work in a moderately noisy room, like a coffee shop, since it relies on a whisper through a ring?

The trackpad on my finger actually feels intuitive, and whispering notes into Wispr Flow without pulling out my phone is a nice little workflow win.

love how the trackpad and voice capture feel like one continuous gesture rather than two separate tricks stapled together. the choice to keep whisper input private by design is a really thoughtful detail.

Curious how the voice capture actually stays private in public spaces, does it use some kind of bone conduction or just a really tight mic pickup pattern?

Tried whispering notes into it on a noisy train and was shocked the transcript came back clean. The trackpad on the ring feels weirdly natural once you stop thinking about it.

The integration of the trackpad with private voice capture on a single ring is seriously clever engineering. Curious how the microphone isolation handles whispers without picking up ambient noise around you.

The "quiet spaces" use case is what sets this apart. Voice already works well when you're alone - the gap is all the moments you can't really speak out loud.
Curious how this holds up after a couple of weeks though. Does it actually start replacing the keyboard, or do people still fall back to old habits?
Congrats on the launch!

Leaving out health tracking on purpose is the right call, most rings try to do everything and end up mediocre at all of it. The whisper mode is what got me though, going from whisper volume to clean transcription is genuinely hard since background noise and breath sounds usually wreck it. Is the mic picking up any bone conduction from the finger too, or purely air, and does it hold up in a noisy cafe vs a quiet room?

does the 2D trackpad stay usable if the ring rotates slightly during the day?

This feels like a very “future interface” product :)

I like that you didn’t try to make another health ring. focusing fully on interaction makes the product much more interesting to me, because voice alone still has limits and touch alone would probably not be enough either.

The Wispr Flow integration also makes a lot of sense. I use voice more and more for writing/thinking, but the awkward part is exactly public or quiet spaces where speaking normally feels weird. whispering + finger-level editing could solve a real friction there.

The trackpad part is probably what makes this feel different from “just voice input in a ring.” being able to scroll, edit, and control text without touching the keyboard is a strong direction. Curious how hard it is to learn in practice. does it feel natural after a few minutes, or is there a real learning curve before the ring becomes faster than keyboard/mouse?

How well does the voice capture work in louder settings, and is the Wispr Flow integration included in the ring's price or a separate subscription?

Big fan can't wait to get my hands on these. Lavalier microphone's are a bit of an eye sore big opportunity for software to bridge the gap on the core audio specs.

The decision to keep voice capture private on something this small is genuinely impressive engineering. Whispering into a ring without it picking up the room around you is a much harder problem than it sounds.

How about water resistance? Could I wash my hands while wearing it?

Honestly the whisper-to-dictate part feels like the real magic here, super handy when you're in a quiet office and don't want to look like you're barking at your laptop.

The trackpad on a ring still feels a bit like magic, and pairing it with Whispr for quiet dictation makes it way more practical than I expected.

This looks impressive . I'm curious if I deploy with one open source model today and decide to switch to another later does Run Infra automatically re-optimize everything, or is that something I need to trigger manually?

One thing I like is that you're optimizing for production instead of making demos easier .Lots AI tools get you to Hello world but far fewer help with latency cost, and scaling once people actually start using the product.

Tried, hit a few errors during planning, in the end, it deployed something, but it hung on a simple "wazzup" prompt with no recovery. Nice UI though

Oh, and there is no account removal action available.

I think the natural language approach makes this platform stand out. i have always preferred explaining what I want instead of navigating multiple dashboards and configurations screen.

Abstracting model selection and kernel tuning behind a plain description is a good bet for teams without an ML infra person. How opinionated is it, does it pick the architecture and hardware or mostly optimize what you hand it? The gap between 'I need X' and a deployed model is where most people get stuck.

how does the pricing actually work when you hit something like a custom CUDA kernel being generated, is that a flat fee or does it burn through tokens while forge is reasoning?

This looks cool! I have started playing around with inference optimisations! Wondering is there a way to learn and contribute at the same thime.

Spent a weekend chatting with RunInfra to spin up a voice-to-text pipeline and the custom CUDA kernel step actually beat the latency i was getting on my old setup. Pricing by the million tokens with scale to zero is a nice fit for the random bursts of traffic i get from indie clients.

how does the cuda kernel generation actually work in practice, does forge just spit out a kernel you can drop into vllm or does it need a custom serving stack on your end

how does the per-token pricing actually compare to something like runpod or modal when running something like a 70b quantized model for a few hours a day?

how does the pricing per million tokens actually compare to something like runpod or modal when you're running a custom kernel workload, especially at lower utilization?

Tried it with a small vision model this morning and the speed jump over my usual setup was noticeable right away, plus the per-token pricing is way easier to stomach than the GPU bills I was getting before.

Tried it with a vision pipeline and the custom CUDA kernels actually beat the hosted version I was using. The plain-language setup is refreshing, no YAML rabbit holes.

How does the custom CUDA kernel generation actually work in practice, does Forge learn from existing kernels or write them from scratch, and what happens if the generated kernel underperforms the standard one at runtime?

Spent a few minutes describing a doc search use case and the generated API was already hitting it faster than my usual setup, the per-token pricing is a nice touch too. Curious how the custom CUDA kernels hold up on weirder workloads.

Tried spinning up a vision model just by describing it and it actually returned a working endpoint, no dashboard digging required. The custom CUDA kernel generation is a wild flex for a chat interface.

How does the Forge agent actually decide when to write a custom CUDA kernel versus just relying on quantization, and does that choice change the price I pay per million tokens?

Tried spinning up a custom voice pipeline in the chat and it actually worked without me touching a config file. The CUDA kernel generation for a smaller Llama variant was way faster than I expected, ran cooler on my GPU too.

Auto-generating custom CUDA kernels is the part that would make me nervous to trust blindly. A kernel can be fast and still be subtly wrong on edge cases, like a numerically unstable softmax or a padding bug that only shows up on odd sequence lengths. What's the testing story before a generated kernel goes into a production API, do you diff outputs against the reference implementation across a range of inputs first?

Nicee

Osama, the part that lands for me is not having to become an infrastructure expert just to get a model running properly. That barrier has quietly killed plenty of good ideas, so seeing it lowered is refreshing.

Building production APIs from plain English and auto kernel optimization feels like the direction a lot of us need. Especially for voice/vision stuff where every ms counts.

How's the Forge agent doing on more complex full-app descriptions so far?

Hey everyone! 

Today, after two years of hands-on development, for the first time, we are excited to introduce Metal to the PH community. Metal is an AI-native operating system for founders raising venture rounds.

Prior to starting Metal, I raised $120m for my first startup across seven venture rounds. 

Through that experience, I learned that fundraising was a game of guesswork – you hit up people that you think may be able to introduce you to investors, and you try to identify investors that you “guess” would be interested in your Company. With Metal, our goal is to replace the guesswork that goes into fundraising with data and intelligence. 

For founders raising VC, Metal brings deep capabilities for investor discovery and research, for relationship intelligence to get the most out of your network, and for managing your investor pipeline with everything in one place. Today, Metal is used by thousands of founders across 40+ countries while the platform remains in a phase of rapid evolution. You can learn more at www.metal.so.

This is long overdue. Well done.

I am a happy Metal customer and it has been an incredible help to me in prepping for fundraising. Obviously the database is great, but I was really surprised of the evaluation of all of our context, pitchdeck, progress, etc. and the insight I've been getting on what parts of our approach should we adjust to maximise our chances. Congrats to Usman and team on the launch! Big up from me!

We used Metal when it was in beta. Amazing product for finding investor fit and subsequent reach out. Usman is also a really nice guy. Everyone should run their early fund raises through Metal!

Spent a few minutes poking around Metal and the investor mapping stood out, it actually shows warm intros based on shared investors or founders rather than a generic list. Feels like a tool built by people who've been through the fundraising grind themselves.

the investor relationship mapping is genuinely useful, way more organized than my usual spreadsheet mess.

The investor mapping feature feels really solid, way more useful than just dumping a CSV of names. Surprised how fast it pulled in warm intros from my existing network.

the investor discovery actually pulls real context on the funds, not just a name dump. round copilot saved me an hour of digging through my own notes before a partner call.

the investor discovery mapped out people i never would've found through cold searches, and the round copilot actually feels like a real cofounder nudging you on next steps

Metal has been a game-changer for my fundraising. Recommended by a VC I was talking to, and it's lived up to the hype. The investor discovery piece alone is worth it, surfacing investors who are a fit for my stage and thesis.

The AI features are genuinely useful and intuitive enough that I was getting value in my first session. As a founder juggling fundraising alongside everything else, having a tool that does the relationship mapping and prioritization for me has saved a ton of time.

Highly recommend for any founder in raise mode.

How does the investor relationship mapping actually pull in data, is it mostly LinkedIn scraping or are there deeper integrations with CRMs like Affinity or Attio?

the investor mapping flow feels genuinely thoughtful, not just a glorified CRM dump. loving how the round copilot actually pulls context from past conversations instead of being a blank prompt box.

How does Metal actually source and keep its investor data fresh, and is that included in the standard plan or do you pay separately for premium investor intel?

The relationship mapping view is genuinely smart, way more useful than another CRM dressed up with AI buzzwords. Solid execution from a team that clearly gets how chaotic raising actually feels.

genuinely curious about one thing here - if a lot of founders end up using the same AI tool to find the same best-fit investors for their stage and thesis, doesn't that create a wave of very similar-looking outreach hitting the same small pool of partners at once. does Metal do anything to help founders differentiate the actual pitch, or is the value purely in finding the right names faster

The investor mapping view pulled up connections I didn't even know existed through my existing angels. Really useful for warm intros before a round.

Does the round copilot pull in data from my existing CRM or email, or do I have to manually maintain investor relationships inside Metal from scratch?

The investor discovery view is surprisingly well organized, felt closer to a CRM than the usual pitch deck graveyard. Curious how the round copilot handles follow-ups when investors go quiet.

The relationship mapping view is genuinely sharp, surfacing warm intros without the usual spreadsheet gymnastics. Really thoughtful execution for founders in the weeds of a round.

How does Metal actually decide which investors to surface, and can it pull in warm intros from my existing network automatically or is the relationship mapping something I have to feed in myself?

Really like how the investor mapping feels more like a relationship graph than a cold list. The in-app round copilot sounds like a smart move too.

the investor mapping view was honestly more useful than i expected, surfaced warm intros i didn't know existed

The investor relationship mapping is genuinely useful, finally a way to keep track of warm intros without a messy spreadsheet. Wish it had this when I was fundraising.