PH热榜 | 2026-06-28

@peterbuch Love the eco angle, nobody frames model choice this way. The failure mode I'd worry about: eco-routing picks the frugal model, it under-delivers, the user re-asks or you retry on a bigger one, and now you've burned MORE CO2 than just starting with the right model. How do you avoid the cheap-first-then-escalate tax, predict task difficulty up front, or does that retry cost get hidden from the readout? 

@peterbuch Congratulations to you and the team first for building and second for the launch. I completely know the amount of work and dedication that went into production to finish line. One question, most AI model have memory of user's activities or tasks. When multiple models are dispatched across a single task or conversation, how is memory and context handled? Does discode maintain a central context layer, or does each model only see what's passed to it at that moment?

@peterbuch Congrats on the launch !!!

The Eco angle is what really caught my attention. We talk a lot about model quality, speed, and cost, but almost never about the environmental impact of choosing one model over another.

One thing I’m curious about: after seeing the CO₂, water, and energy estimates, do users actually change their model choices, or do they mostly use the data for awareness? I'd love to know if you've seen behavior shift because of that transparency.

Also, Challenger Mode and Trio Mode sound like really fun ways to improve confidence in AI outputs.

Excited to see where this goes.

@georg_kopetz Lieber Georg, thank you, that means a lot, especially from you.

Those two are the heart of it for us, and really one idea. The on-device privacy filter is the sovereignty part we care about most: your data stays on your own machine, so using AI doesn't quietly hand Europe's data and value to infrastructure we don't own or control. The eco side is the other half, and a week like this makes it painfully literal (this heat we're both sitting in is no joke). That's the different race we'd rather run: not who builds the most powerful system, but whether Europe can build AI that stays sustainable and keeps the person in control, here, on our own terms.

We're early and we own it, the eco numbers are estimates and a first step, so having you see what we're reaching for is real fuel. Thank you, and stay cool in this heat.

Mo

@georg_kopetz thank you, Georg!!

@harald_lustinger1 thanks Harry, it's been a fun working with you and the time. Let's keep making discode better

@harald_lustinger1 Harry, the whole look people are falling for, the characters, the disco, the way it feels calm instead of techy, that's very much you. Thank you for giving discode a face that's actually a joy to look at. Plenty more to explore on the visual side together. 🪩

@mo_riz it's been a great pleasure working on this mission with you and the team.
Let's go!

@martin_mo Martin, agree, it's bold, and it's a lot of models. For us it was important to make sure we have the best model for each task, so we are starting with many. Regarding the ECO we are still in an R&D phase, but what you're mentioning is certainly important: less wasted compute, smarter routing, also using the model that's good enough but not overkill.

@juan_sebastian_gomez it's been great working with you on this. Let's keep it up

@juan_sebastian_gomez An act of resistance against the extractive, engagement-driven logic behind most of the internet" is exactly the race we wanted to run, Sebastian, and you helped us actually mean it. Thank you for caring about the why as much as the what. And yeah: it's live, and it's for everyone. 🪩

@juan_sebastian_gomez exciting to see where we can take the disco(de)

@yibo_wang3 thanks so much, Yibo, happy it resonates

@alexandra_prasch thank you, Alexandra. Also a big fan of that feature. Please let us know if you have any more feedback, happy to chat

@artstavenka1 Hi Art, you've put your finger on two of the things we care about most, and the transparency you mentioned, showing which model answered and why, is deliberate for exactly this situation.

On the honest part: yes, a re-ask counts. Every attempt is metered, in cost and in CO₂, water and energy, so on a genuinely hard prompt a couple of tries can outweigh a single direct call. We don't pretend otherwise, and that visibility is the point: you get to see it and decide, rather than us quietly spending more on your behalf.

Where we're headed is smarter about this: escalation that can bump a weak first answer up a tier without a full manual retry, and folding your retries back into routing so the system learns from them. The data for both is already being logged, so it's a matter of wiring it through. Thanks for the nudge, this is exactly the kind of feedback that shapes what we build next.

Great question, you've put your finger on the exact tension, and we take it seriously.

First, the difficulty call. Selection runs on domain, speed, cost and eco together, bounded by where you've set your Turntables (Smarter, Speed, Eco). The domain benchmark does a lot of the work, since a coding question and a casual translation have very different model requirements; we route within four tiers, so light tasks stay cheap and low-footprint while harder ones escalate to specialists or frontier models. On top of that we classify every prompt for complexity, output shape and task type, plus a few other signals. I'll be honest about where that stands: those signals are captured and stored against actual outcomes, but not all of them are live routing inputs yet. We're building the calibration dataset first, so that when they do shape selection, the thresholds come from real data rather than intuition. Two things keep it honest in the meantime: every answer shows which model ran and why (no black box), and when the routing misses, your feedback flows straight back into the model choice. The tiers aren't static either: a nightly sweep re-scores all 100+ models on fresh benchmarks, pricing and real user signals.

On verification, I'll be straight with you: we don't claim to know what a frontier model "would have said." There's no crystal ball that runs for free, no oracle, and you can't check that without running the frontier model yourself, which burns the eco budget you just saved. So no phantom comparison. What we do instead is measure: every routed response persists its actual token count, energy and cost next to the complexity classification. The plan is to bucket those outcomes by model, mode and task type, and only let a finer routing rule promote itself if it measurably reduces prediction error without increasing context overruns. Challenger already produces side-by-side quality comparisons; wiring that quality signal into the calibration loop is the next step.

And for the here and now, when truth actually matters you switch on the multi-model check. Trio sends your question to three models from three different provider families; a separate judge scores them blind and in random order, merges the best, and flags where they disagree. Challenger goes the other way: a different family takes one answer apart and rebuilds it over a few rounds. Different families have different blind spots, so what one invents, the others usually catch.

It cuts errors hard, but it doesn't zero them. You stay the judge. Happy to go deeper on any piece.

Mo

@dipankar_sarkar thank you for your question, appreciate you.

@ilko_kacharov agree, thanks Ilko for the feedback. We believe in transparency, and in helping users understand the impact of models used. Let me know if you have any further questions

@ulrikah thanks so much for your support. Great question, yes you can use our sliders to define how important ECO, QUALITY, and/or SPEED is for you. This will determine which models we are using.

@johanna_piffl I'd also be interested in a team plan!

@johanna_piffl great idea, we are working on it.

@shibacodelabs Michael, it's been great working with you on discode. Quite a monster project you've created there.

@veronika_stabinger1 it's been great fun building with you these past few weeks. Excited for what's to come

@veronika_stabinger1 This is the heart of it, Vroni, and a lot of that heart is yours. "Making humans and technology tolerate each other" is the whole job, and the control, clarity and calm people feel is your fingerprint on every screen. Thank you for keeping it human, European, and just snarky enough. Couldn't have danced this one without you. 🪩

@vishal_thakor9 Hi Vishal, great question, and exactly the one that would sink the whole idea if we got it wrong.

The router doesn't run on a heavyweight model, and on simple queries it often runs no model at all. It works in two stages: a fast pattern-matching pass reads the domain, language and locale for zero tokens, and a lot of straightforward queries are fully sorted right there. Only when that pass isn't confident does a small classification model step in, and even then it's a tiny call, cached so repeats and near-repeats cost nothing. The routing decision is then frozen for that request, so we never route the same thing twice.

On whether we've measured it: yes. We log each classifier call on its own, so the router's footprint is something we can read directly rather than hand-wave. In practice it's a tiny call set against the savings of keeping a simple request on a lightweight model instead of a frontier one, so the overhead is a rounding error next to that. And the classifier's own cost sits on our side as infrastructure, not on your bill.

One honest nuance: difficulty alone doesn't pick the model. It feeds a tiered score across domain benchmarks, speed, eco and price, weighted by where you've set your sliders, so the classifier informs the decision, it isn't the decision. Happy to go deeper if that's useful.

Mo

@vishal_thakor9 Vishal, appreciate your question, please let us know if you have any further questions

@hazy0 You're zeroing in on the exact thing that makes naive redaction useless: black out a name and the model loses the thread - coreference breaks, the answer turns incoherent.

So we don't black anything out, and you don't have to hunt for the sensitive bits yourself. A local assistant does that on your device, before anything leaves: pattern matching catches the structured stuff (email, phone, IBAN, cards), and a small model running in your browser catches names, companies and places. It surfaces every find and proposes what to anonymize; you approve or override per data point. The assistant does the work, you keep the decision, and nothing is uploaded just to detect it. That is what makes it safe in front of a team: nobody has to catch every name or IBAN by hand before hitting send.

Each detected entity is then swapped for a realistic look-alike, and that stand-in is baked into the conversation history that travels with every request. When something introduced 10 messages back is needed now, the model reads the same consistent stand-in from that history - a coherent conversation of plausible people, not a wall of [REDACTED]. You see your real values; the model only ever sees the stand-ins.

That real-to-stand-in map lives only on your device, in your browser - never logged, never in our database, never sent to our servers. That's also why the next edge exists at all.

Honest edges: detection isn't perfect (rare spellings, or an identity that only emerges from combining several harmless details); the map is device-local, so ask on your phone and open the thread on your laptop and you'll see stand-ins there; and restoration is a literal match, so if the model reformats a stand-in - abbreviating "Street" to "St.", changing case, inflecting a name - that spot can show the plausible stand-in instead of your real value. That last one is cosmetic, never a leak: the unrestored text is the fake, and your real value never left your device.

@hazy0 thanks for your question, let us know if you have any more feedback, thank you

@priya_kushwaha1 thanks Priya, that's a great question. There currently isn't any way to bring corporate credits to discode, but that's certainly something we are looking into.
Happy to chat more, if you have more feedback, thanks again for your support.

@elias_motionfy Elias, great question, and totally agree. We have just launched into beta so we don't have much data on user behavior yet. We certainly hope though that we can bring actual change in behavior. Do you think that's possible?

@elias_motionfy  Hey Elias, grüß dich! Always good to hear from someone in the Austrian AI scene. And yeah — forcing everything through one

  pipeline is the expensive version of learning that lesson.                                                                 

  On your question: honestly, too early to say with certainty. What we do see is that the transparency itself changes the    

  conversation. Once people realize their one-liner just cost 50x what it needed to, most don't need a second nudge — they

  let the router do its job. Whether that's behavior change or just trusting the system to be frugal for them, the outcome is

   the same: less waste, better fit. But we'll know more once we have real usage data at scale.

@magichsin thank you so much for the comment, and the encouraging words. Always happy to chat more.

@ariaxhan hey Aria, great question. It's one of the biggest challenges for us to make discode a success. It's also something that I cannot publicly share. Happy to talk more in a one on one chat if you'd like though. thanks so much for supporting our launch.

@ariaxhan   dear aria, The routing uses a combination of domain-specific benchmark data from public sources and our own evaluation layer. Each query gets classified by domain — coding, math, legal, creative, etc. — and models are scored against the benchmarks that actually matter for that domain, not just one generic leaderboard.

On top of that, users steer with sliders for quality, speed, eco; so the "best" model is always relative to what you actually need right now.

As for keeping up: our model radar continuously screens for new releases and benchmark updates, so the catalog stays current without manual intervention. When a new model drops, it gets scored and ranked automatically — no waiting for the next release cycle. any more questions? feel free to ask thx

@sleekzheng Love that you've been building in the space. We do have a main model, but are still optimizing, switching models and doing a lot of testing. What made you use Codex for the task?

@christian_knaut 

Christian, you're touching on exactly the hard part. The CO2 footprint of a model call is a product of several compounding factors:

Hardware type and efficiency - different chip generations have noticeably different energy profiles per token

Batch utilization - a GPU running well below capacity burns power roughly comparable to one running near full load, so how many requests share the same hardware matters a lot

Datacenter location and grid mix - this is the biggest lever.

A model running on a low-carbon grid sits at a fraction of the footprint of the same model on a coal-heavy grid; the gap between them can be substantial for identical compute

PUE (Power Usage Effectiveness) - the overhead of cooling, lighting, and facility power on top of IT energy, which varies significantly by datacenter design

Water use - often overlooked, but cooling systems consume a meaningful amount, and we track this as well

Model architecture - for MoE models, only a portion of parameters are active per token, so using total parameter count would meaningfully overstate the energy cost

Decode vs prefill split - generating output tokens costs noticeably more energy per token than processing input, so a short prompt with a long answer looks quite different from the reverse

For all of these we rely on publicly available data - mainly grid intensity figures and published datacenter environmental reports - and we've formed a working group with ESG-Cockpit to sharpen the methodology.

The honest limitation: closed-source model architectures have to be estimated, and Scope 3 emissions (hardware manufacturing and supply chain) are excluded, which is industry standard but still an undercount. We flag that in the product.

It's an evolving picture and we're actively working to close the gaps.

Let me know if you have any further questions

@prashant_patil14 Thanks for the kind words. Transparency is exactly the part we obsess over.

The design goal: the best router is one you can ignore completely, but the moment you look, nothing's hidden — and you never need a technical background.

Instead of picking from 100+ models in a dropdown, you steer with three controls — Quality, Speed and Eco — like an equalizer. You set the vibe, the system picks the lane: simple questions go to fast, low-footprint models, harder ones move up to stronger ones automatically. Every answer shows the model that handled it right beneath it. And if you'd rather drive, a manual override is one tap away.

Where it gets really visible is Trio mode: you watch multiple models work the same question side by side, in real time — no hidden orchestration. We're also planning out a plain-language "why this model" explanation on every answer, so the reasoning is one tap away, not a black box.

Let me know if you have any further questions

dear @dipankar_sarkar Spot on, and no, the nightly sweep isn't doing double duty: it recalibrates which model wins within a tier, not the tier boundaries themselves. The second loop you're describing doesn't exist yet. A re-ask today is just another request, not yet a correction signal. Re-asks as free labels for "this domain was under-tiered" is exactly the right framing, and the version worth building first. Thanks for sharpening that. thx

@veronika_stabinger1 exactly, you have all the models and you don't have to think much about which one to choose. But if you want to go deep you can

@dipankar_sarkar Great question, Dipankar, and you're pointing right at the gap between where we are and where we're headed.

It helps to split it into two loops, because they sit at different stages.

The nightly loop is live: a sweep re-scores the whole model catalog on fresh public benchmarks (coding, math and reasoning indices), current pricing, and aggregate usage. So which model wins inside a tier does shift over time. To be precise about the feedback point: that movement happens at the catalog level, not yet from your individual behavior.

The after-the-fact loop you're describing, a re-ask read as "this tier under-served me" and fed back to recalibrate the domain benchmark, is not closed yet. And I'd rather be straight than impressive here. We built the telemetry layer first: every routing decision is fully traceable, each answer is stored with its tier, the model that ran, your slider settings and your rating. The data foundation is solid. But that data doesn't drive selection scoring yet. The adaptive wiring on top is the next layer, not a shipped one.

What closing the loop looks like for us:

•⁠ ⁠Per-user affinity: if one model keeps earning top ratings on your coding prompts and another keeps missing, bias your future coding selections accordingly.

•⁠ ⁠Domain recalibration: enough low ratings on eco-routed math prompts raises the minimum tier floor for the math domain.

•⁠ ⁠Regen-cost awareness: when an eco route triggers a retry cycle that ends up costing more than a direct frontier call would have, surface it as a nudge ("your last few eco prompts needed retries, consider bumping Quality"). An eco route you have to redo isn't actually green.

So, honestly: today it's mostly static between catalog refreshes, with the telemetry already capturing exactly what the adaptive layer will need. You're describing precisely what comes next.
mo

@dipankar_sarkar thank you for your support & questions

@petersamokhin How can I pair it with Claude to share compressed images automatically ?

@petersamokhin

Hi Petr,

I came across @GetCompress on Product Hunt — really interesting positioning. I create Turkish-language AI content on Instagram (@yucel.kelci ) (458K followers, 20M - 50M monthly views). Turkey is one of the fastest-growing AI adoption markets right now and there’s almost no quality Turkish content covering tools like yours. Would you be open to a sponsored content partnership? Happy to share my media kit.

@petersamokhin congrats on the launch !

I definitely relate to the "just let me drop a file, compress it, and move on" workflow. It's one of those tasks that should take seconds but somehow ends up breaking your flow.

One thing I'm curious about: among your early users, what file type surprised you the most in terms of compression results? Was there a format where people consistently said, "I didn't expect it to shrink that much without noticeable quality loss"?

Also, the MCP integration is a nice touch. Feels like a natural fit as more AI workflows start handling media.

Wishing you a fantastic launch!

@danshipit thanks a lot, I've been cooking hard on every pixel 👨‍🍳

@itruf thanks a loooot!

The compression logic is open-source and is available here: https://github.com/getcompress/extensions/tree/master/packages/extension-gif-optimizer

If you create a GIF from video, it's first converted using optimized approaches (with advanced colour palette for it to look fancier!)

Then (or initially, if you already had a GIF), it's compressed using an in-house developed tool that handles lossy compression in a way similar to lossy PNG compression: adaptive color quantization, weighted histogram, dithering, palette posterization and deduplication... many buzzwords but the point is that it's a very optimized and stable algorithm that helps making the GIFs look great but have a small file size!

@martin_mo thanks a lot! The app is fully local, no network access is required after installation 🔐

@racine_g hey, thanks a lot for asking my favourite question!

There are many aspects that help reaching the best compression levels on the market, and I'm happy to share the secrets... just kidding: all compression logic is actually open-source, because GetCompress' main focus is your best UX! See it here: https://github.com/getcompress/extensions

Just a few examples:

• Videos: not just simple params like CRF are blindly used, but instead I carefully tested each format and made sure all advanced settings are applied, aiming at the fastest compression and smallest file sizes. For example, if you want a WebM video that will be fastest to load in your blog, the best codecs and compression params will be selected. Or, if you have a MacBook, you can benefit from Apple native VideoToolbox

• PDFs: any image-heavy files are analyzed in a smart way (e.g. detecting actual non-transparent images and any unnecessary info) and images are compressed separately (for example, lossy PNG compression is unbeatable!). I also did it myself (unlike competitors that use GhostScript and violate their open-source license that way!), so now even the edge cases like PDFs with form fields are handled carefully & not broken

• Images: an in-house utility compresses even PNGs, in a lossy way, with veeery smart algorithms applied!

• GIFs: multi-step logic that utilizes FFmpeg, Gifsicle and an in-house tool for even better lossy compression

I can dive into more details if you're interested!

@german_merlo1 thank you very much for your kind words! 🫶

@nonews thanks a lot! I was trying to make my AI assistants work with media compression reliably but it just became weirder every chat, so I invested time and supported it in GetCompress. Glad it helps you too! 🫶

@sergei_a_korban thank you very much for kind words! Upload limits are a huge pain and probably the number one, and solving it & allowing to do it without context switching between apps was my highest priority 🧲

@andrasczeizel hi Andras, thanks a lot for your comment!

You can control the quality by choosing the predefined presets, or set up e.g. target file size, or if you prefer you can even select some advanced settings (such as media codec, frame rate and almost anything else!)

After you apply your desired settings, you can save that preset and reuse it later:

@artstavenka1 I see a pro here, thanks for asking!

You can control Apple native handling in settings, and switching to x265 is just one click (see screenshot), but also I added a lot of smart logic, that depends on the file format, and might try different fallback settings in order to get the smallest file possible ✨

@dmitry_manko wow, I didn't expect any interest on mobile side 👀

No plans for the nearest future, but probably I'd have to reconsider it!

My main idea was that you can't do this on mobile:

https://youtu.be/68AuSlchZto

@timur_masalimov hey, thanks a lot for sharing your feedback 👋

The main benefits of connecting to GetCompress MCP (vs just telling your agent to "compress it somehow"):

• reliability: Claude won't hallucinate and install some outdated CLI every time you ask for media compression, and you don't even need to write a detailed prompt that covers any possible edge cases

• better compression: the curated advanced logic already knows how's best to reduce the file size while keeping visual quality as best as possible, because just with some default params you could receive a pixelated result that is not really small in size

• speed: magic optimizations such as Apple native frameworks (VideoToolbox) sometimes can do magic!

So, you after connecting the MCP, could ask your AI assistant to prepare you a demo and ensure it's compressed nicely (just with natural words), fit some upload limits to Notion, and anything else!

@stanislau_zamana this one was unexpected 🫢

To be honest, I didn't plan on the mobile apps, as I mainly aimed to improve and speed-up frequent compression flows (which is easier & best done from your laptop, Mac or Windows), but I'll definitely consider it for the future!

@luki_notlowkey hey, thanks a lot!

Surprisingly, images were much more tricky to ensure the "perfect production-grade compression" across all images, due to the number of extensions, edge cases, and some additional advanced algorithms to be introduced (e.g. a proper lossy PNG compression).

@jackrmcdermott thank you very much!

@byalexai bro idk what compression does it use, all code was removed in order to get rid of bugs!

Re: serious note, it's balanced by doing a lot of hard work on testing it & optimizing & using hundreds of test files, to ensure all input and output formats perform great! There are many tricks, and if you dig deeper, there are always additional params & optimizations which people often miss (and which Claude won't tell you even with an advanced prompt!)

The compression logic is open-source btw: https://github.com/getcompress/extensions

The 3rd party tools like FFmpeg are also built publicly, which is how I endured to support more advanced params & codecs, and e.g. make it possible to use Apple native VideoToolbox to improve it even further: https://github.com/getcompress/media-tools-binaries

@igor_martinyuk yooo the GOAT is here! Thank you very much!

@galdayan thanks for a detailed question!

The less optimized video is initially, the more it gets compressed, and 70% are passed regularly 🗜️

Not only codecs matter, but the additional compression params too (they might affect both speed and result file size), and you can choose codecs in 1 click, if you wish: it's H.264 by default (or Apple native VideoToolbox is used if you turn it on)

You can also quickly switch to WebM and OFTEN go past 90% compression without visible artifacts: WebM + AV1 is now widely supported and is a GOAT free format ⚡

@alexey_getman thank you very much, it's very high effort 🙏

@nanimono_masa thanks a lot for asking this! It's actually much better than ZIP, as you can't reduce video/image/PDF file size by just zipping it. This is where GetCompress helps the best!

@omri_ben_shoham1 hey, thank you for your question! Yes, GetCompress supports RAW format, and also some Apple native optimizations to handle it faster & with better quality ⚡

@alex_gorodnitskiy thanks for an advanced question! To be honest, in many cases already optimized formats much less benefit from additional compression, but re-encoding with advanced params or Apple native codecs sometimes helps even further 👀

However, the main use-case for GetCompress is compressing any kind of media that is produced by any tool in your work, before uploading it or using elsewhere, so you can get WebP and AVIF or compressed MP4 safely & quickly in batches!

@aleksei_martoias you are not gonna believe me but it's already available there, both ARM and x64 👀

@bugorbn thanks a lot for your kind words! Fun fact: my main flow was especially uploading demos to Jira tickets & PRs & bug reports up to a few times per day too, so this idea came from real pain due to be solved 👀

@foxecila thanks a lot for your kind words! Drag and drop is my favourite part, I can even say that's the reason why I'm here today 😺

@runtypelabs  @runtypical  how do you think about auditing WebMCP tool usage once a product is live? The integration story is strong, but approval traces and debugging seem like the part teams will care about most after the first demo.

@runtypelabs  @runtypical  The WebMCP bet is the interesting part beyond the chat UI. Honest question: is WebMCP an actual emerging standard that browsers and agents will converge on, or your own convention for now? The payoff (any agent reading the page's exposed tools) only lands if it isn't Persona-only. If a future Claude or ChatGPT browser extension can read those same tool registrations, that's huge; if it's a closed loop it's a really nice chat widget. Where does it sit today?

@runtypelabs  @runtypical If the underlying app or input shape changes, how does Persona.js fail before it quietly gives me a bad result?

@dipankar_sarkar yes! Similar to the protections that MCP tools typically have in chatbots and harnesses today, WebMCP tools can be tagged based on whether or not they are 'read-only' or mutative/potentially destructive, and Persona (in collaboration with the agent backend) can support HITL (Human-in-the-loop) approval flows for those actions.

This can be seen on demos like these:

https://www.persona-chat.dev/approval-demo.html (also has a great example of a Persona plugin)

https://www.persona-chat.dev/webmcp-demo.html ("Add to cart" requires approval)

On the general topic of WebMCP security, both Persona and Runtype have adapted Google's best practices around WebMCP security, which you can read here:

https://developer.chrome.com/docs/agents/security

https://developer.chrome.com/docs/ai/webmcp/secure-tools

@vikramp7470 great question - the polyfill is both lazy-loaded and defensive; it won't waste any resources at all if WebMCP is already discovered on the page, even if it's from another polyfill. In fact, the entire initial page weight of Persona is only about ~15kb, to minimize the performance hit when embedding.

@i_sanjay_gautam Thanks! WebMCP tool registrations can theoretically invoke any javascript function living on a page, as well as be added as a decorator to existing HTML forms.

For frameworks like Next.js or React you can use plugins to easily hook into your existing actions and expose them as WebMCP, although I'd always encourage folks to intentionally design your tools around the needs of the agents - I personally love Arcade.dev's guide on MCP tool design, and I think the same principles apply to WebMCP!

@galdayan Great question! There are essentially two paths, which you can blend together based on where the auth checks already are.

1) Handling auth context on the API side. Usually you are already streaming LLM / AI framework calls through the backend so the state of the user is already available. Persona has examples of using a proxy to do this in the repo as well.

2) Using WebMCP to respect the auth context automatically. Since the tools are being called on the frontend when you use WebMCP, you can pass the signed in user's identity as part of the existing function calls. If your app's frontend works with signed in context today, you might not need additional backend work.

@grace_lee26 Persona has a lot of knobs here - we support tool call approval by default (and map it to how the WebMCP tools are configured), and you can make the display of the tool call details more or less verbose based on your preference as a builder.

There's a demo here that shows more about how this works:

https://www.persona-chat.dev/approval-demo.html

There's also a fun example of a Persona plugin on this page!

@dipankar_sarkar yes, in this model all the tool calls are ultimately emitted by the server and executed on the client, so there is nothing the server is not aware of; it is the initiator.

Naturally the browser is an insecure environment and the output itself needs to not be fully trusted, which is where server-side frameworks like Runtype implement (or should implement) appropriate guardrails and similarly site owners should follow best practices. The Chrome team has been appropriately conservative in their initial release and I would expect to see browsers adopt incremental improvements to CSP for example to limit the ability for arbitrary 3rd-party scripts to inject malicious tools.

@dipankar_sarkar to back up what @runtypical is saying on the server side, in practice we've done a few things there alongside the client tool calling in Persona to make it easier to execute safely.

1) Define tool params as 'protected' which will be filled in outside of the LLM. The model doesn't see the param ever, as we inject them server side before the tool call event is streamed back.

2) Run tool calls through an explicit "local" tool call path, which escape hatches out of the main loop like a approval step, but for tool calls you want to process specifically through another server / harness / etc. WebMCP support in Persona uses a form of this, made more generic on the client side so any platform can implement it too.

We optionally store the full input and output for every call when Runtype is involved, which can be included on the streamed events as well so your server proxying the request can use all of that data to decide on the fly. We provide a server side SDK to hook into what is streamed for those advanced cases.

@dipankar_sarkar thank you for the nuanced question! The HITL gate is per-call from Persona's perspective, but keep in mind that Persona is only the client-side of the equation when making a chat agent w/ WebMCP capabilities - and indeed the second half of the equation is the server-side agent framework, which is where most of the defense-in-depth should be from a security perspective. When connected to Runtype, you can apply further policies on top of the registered WebMCP tools.

Ultimately site owners & platforms do have a responsibility to design tools well (or use trusted frameworks/extensions to expose tools), just as they've had responsibilities for all other matters of site security around XSRF and so forth.

I would argue that feeding the result of a read-only tool into a mutation is, most of the time, a feature! An agent that can read state and use it to inform the next call is what makes copilot experiences feel very intelligent, so they shouldn't be rejected out of hand, just designed defensively.

@blah_mad sounds like you've built something real before :)

So while Persona does have built-in event debugging in the UI you can optionally turn on (screenshots attached), there is also a deeper set of JS events you can listen to for messages, results, approvals etc in a lot more detail: https://github.com/runtypelabs/persona/blob/main/packages/widget/docs/PROGRAMMATIC-CONTROL.md?plain=1#L562

The messages in particular seem to be right up your alley for the deep debugging use case:

type AgentWidgetMessage = {
  id: string;                    // Unique message identifier
  role: "user" | "assistant" | "system";
  content: string;               // Message text content
  createdAt: string;             // ISO timestamp
  streaming?: boolean;           // Whether message is still streaming
  variant?: "assistant" | "reasoning" | "tool";
  sequence?: number;             // Message ordering
  reasoning?: AgentWidgetReasoning;
  toolCall?: AgentWidgetToolCall;
  tools?: AgentWidgetToolCall[];
  viaVoice?: boolean;            // Indicates if user message was sent via voice input
};

You'd get that info by hooking into Persona init and watching for the assistant messages:

window.addEventListener('persona:chat-ready', (e) => {
  const handle = e.detail;
  handle.on('assistant:message', (msg) => console.log(msg));
  handle.open();
});

// or

const chat = initAgentWidget({
  target: 'body',
  config: { apiUrl: '/api/chat/dispatch' }
});

chat.on('assistant:message', (message) => {
  console.log('Assistant message sent:', message.content);
  if (message.viaVoice) {
    console.log('Message was sent via voice recognition');
  }
});

@erik_christensen really appreciate your real-world validation, it was great to see how cleanly Persona's capabilities mapped to the needs of your team. I think you'll be a great real-world success story very soon as you get to production with it - can't wait to see what you build.

@erik_christensen exactly. I love the emergent benefit you get from thinking about the frontend as a source of tools. Many times the logic you already built there is 1:1 with what you’d want an agent to perform.

@odeth_negapatan1 thanks! And yeah, we have tested on WordPress and Shopify. Persona drops in great there because you can use the script tag (CDN) deployment which doesn’t need a build step. All the init and theme configuration can be set in script tag data params.

We spent a lot of time determining the right loading methods for each type of site. Getting the different methods working in the same library while keeping the bundle size tiny, without regressions in functionality, was not easy.

@yibo_wang3 we agree! A lot of our motivation for Persona was from having used one too many AI assistants who had no idea who I was, asked for me email when I was already logged in, asked me for a piece of information that was already on my page in front of me, etc.

WebMCP integration is the most elegant solution to that problem we've come across, and alignment with the standard has yielded benefits. We're stoked that investment in WebMCP means site owners can add great assistant tech to their site today while also future-proofing for more sophisticated browsing agents of tomorrow.

@localdeclan “Hi Declan,

I came across Dotient on Product Hunt — really interesting positioning. I create Turkish-language AI content on Instagram (@yucel.kelci ) (458K followers, 21M - 50M monthly views). Turkey is one of the fastest-growing AI adoption markets right now and there’s almost no quality Turkish content covering tools like yours. Would you be open to a sponsored content partnership? Happy to share my media kit.”

Happy to share my media kit — or you can view it here: https://drive.google.com/file/d/1J72dHqC6BXdEfKHs320vBtKz2XoJ0KI-/view?usp=sharing

@localdeclan This is a powerful tool

@localdeclan  The offline part is what sold me — most search tools quietly send your files to the cloud. Really smart to keep everything local. Does it work well with large file collections, say 100k+ files?

@martin_mo Search quality is good when you are specific with your queries. One word queries usually aren't too strong but that's what my Signal system is for. Users can shift the embedding space to fit their queries, almost like a super advanced tagging system. The difference really isn't that far if you properly know how to use the software, and in some cases, the local model excels. Especially with super specific queries such as "Bird with yellow beak outside on bird feeder."

@jayant_siktia Thank you very much!

@tkeith In the future there will be ways to sync devices over a wifi connection, but nothing over some external server. That would go completely against Dotient's morals.

@tacitefood Yeah the indexing is manual but it is definitely a high priority now to add some sort of auto indexing after your concern. Regarding the issue with dropping content into the app and nothing happening, theres been a lot of reactivity issues with macos, so maybe do a cmd shift r to refresh the app, switch between pages to see if anything loads in. If nothing happens, try a small batch, maybe 50 files. The processing indicator in the top left is a bit buggy so I definitely have to fix that. Keep in touch with me, I will definitely work to resolve these issues!

@noice30sugar Correct, if you were to label a specific person with a name then it would probably be best to select a few images they are in, maybe lower the threshold a bit just to see all the options. Then if there are certain images that just won't go away and have nothing to do with the person, create a negative signal to eliminate those images. Once the signal is just right, you really shouldn't have to do any more adjusting. Any new image you import of that person, the signal will include it.

@romejerome Great Question Jerome! The answer is absolutely nothing. Nothing leaves your device. Everything is stored in the SQLite DB that is on your device. There is no server besides the small API that simply checks if your license key is valid or not, that is the only time something ever communicates outside of your device.

@dipankar_sarkar Noted!

@dipankar_sarkar This does keep me up at night. Models are only getting better, and yes between different model versions or entirely different model makers, the dimensions that each embedding has to be is almost never consistent. So I'm not too concerned with upgrading the model at the moment since I have spent so long optimizing this one to it's absolute core. However, if it were to happen I would do some sort of lazy migration. Keep old index queryable, slowly re-embed all the files with the new model, run a dual-query between both models and merge the results layer until the old index fully drains. Thanks for the comment!

@david_marko You are indeed right to question that. Dotient runs a hybrid search system, BM25 + semantic in parallel, so anything keyword-findable won't silently fail. But you're right that the deeper "why this matched" question isn't fully solved yet. That's why we introduced this 'Signals System' within the lab page of the app. You can basically shift the entire embedding to what you believe is correct. Relevance is at least grounded in something you define. Proper confidence surfacing and match explanations are definitely on the roadmap, partly due to your concern. Appreciate this comment!

@hi_i_am_mimo Hey Valeria, thank's for the comment! To answer a few of your questions, there is a file watcher put in place for a certain set of basic directories like Downloads, Documents, Pictures and all folders within those directories. However if it is in other hard to find places, the file will be moved to a missing column in the SQLite DB. Users can easily just click on the file (which still does show the image, just a missing path), and update the path of where the file was moved to if it is one of these rare cases. The SQLite DB which holds almost all your data lives in 'C:\Users\[username]\AppData\Roaming\com.dotient.app' and whatever the macOS equivalent of that path is. The webp thumbnails and embedding models also live in that path. Regarding PDF search, we are indexing the text layer and also scanning for images. There is no OCR indexing at the moment, but that may be planned for the future. Obviously you could just highlight a region of the PDF that has text with the rectangle selection tool and probably get a similar search result if you tried searching for that text. The model does understand text to some extent so you are able to search for big words that are in images. Hope this was helpful!

@arystan_tanekov

Hi Arystan,

I came across Lyto on Product Hunt — really interesting positioning. I create Turkish-language AI content on Instagram (@yucel.kelci ) (458K followers, 20M - 50M monthly views). Turkey is one of the fastest-growing AI adoption markets right now and there’s almost no quality Turkish content covering tools like yours. Would you be open to a sponsored content partnership? Happy to share my media kit.

@nanimono_masa Both honestly! I kept losing context every time I switched between tabs and had to re-explain everything to ChatGPT from scratch. That was the personal frustration. Then when we talked to other people we realised it was not just me, it was everyone bouncing between tools all day. That combo is what pushed us to build it.

@martin_mo Honestly the hardest part is exactly what you said, getting it to actually act rather than just suggest. Anyone can build something that tells you what to do. The gap is closing the loop so it does it. That's where most of our engineering time has gone and still goes.

@romejerome Great question. When the data or workflow is messy, Lyto flags the inconsistency and asks for clarification before proceeding rather than guessing and getting it wrong. The goal is to never silently do the wrong thing. Happy to go deeper on a specific case if you have one in mind!

@yibo_wang3 Exactly, most AI makes you go to it. Lyto comes with you. That shift is the whole thing.

@dipankar_sarkar This is exactly the right question and honestly the boundary we think about the most. Yes, mutative actions like sending an email or editing a sheet go through a confirmation step before Lyto commits. You see a preview of what it's about to do and approve it. We are not going to let it touch your inbox without you seeing it first.

@galdayan Really good edge cases to raise. On shadow DOM and cross-origin iframes, if the page is blocking the DOM reader you can always manually select any element yourself and Lyto works from there. Not fully invisible but it doesn't just break.

On memory, context is session-persistent and stays in your history even after you close and reopen Chrome. It doesn't reset on you.

@noctis06 Great questions, happy to be transparent on this.

Memory lives locally in the extension storage on your account, it never leaves your device.

For DOM automation, page content does get processed through our server so the reasoning can act on it. We know that raises valid questions especially as we add Gmail and Sheets, and handling that responsibly is something we are actively building around. Happy to go deeper on the specifics if you want.

@rania_rimali hey,  what happens when the default automated choice is wrong. Does Wirable surface that clearly or only after I hit a bad outcome?

@galdayan Great question and yes, and that distinction is actually key to how we think about scoring.

we separate “discoverability” (can the agent find the feature surface at all) from “execution” (can it complete the action once it’s reached it).
In practice, a lot of failures happen in execution even when the feature is technically exposed, which is why MCP + auth + error semantics matter as much as API surface.
We’re actively refining the model to make those breakdowns more explicit in the next version of the report.

@daniel_nwankwo Thank you so much, please feel free to ask any question, your curiosity will always be satisfied here!

@mohamed_zaidi it's available at wirable.dev, the app offers a generous free tier, plus a 29$/month plan for when you need to deploy mcps, and keep up with your codebase changes :)

@fmerian Nice! This makes sense now. Stumbled upon Schema Source yesterday. So, Schema Source + Tabstack is the combo. Congrats on launch!

@tessak22 OSS ftw!!

@ege_hakan_karaagac when kodwai takes an automated path, what can I inspect or approve before I trust the result?

@elias_motionfy 
"Confidently wrong vs loudly uncertain" might be the best one-line description of agent sessions I've heard. Stealing that.

And it's funny, that reflex is exactly the human side of what we score. The strongest operators front-load it themselves: they state the constraints and the "what about X case" up front (we call it Spec Precision) so the agent doesn't have to guess. Then when it does start confidently wrong, they catch it fast and redirect (Verification Rigor and Recovery).

That's the whole reason we score Direction instead of just the final diff. Those moves, not the typing speed, are what separate a clean session from an hour of cleanup. Would genuinely love to see what your sessions score. The loudly-uncertain ones should do well 😄

@jayant_siktia 
Thank you, this genuinely made my day 🙏 You nailed why we built it.

And ha, that last line is basically the actual test. "Good AI engineer vs just good at accepting suggestions" is something we literally score: Verification Rigor (did you catch its mistakes and push back) and Engagement (did you stay in the loop vs paste-the-spec-and-walk-away) are two of the Direction signals. So you'll find out 😄

Throw Claude Code at a few this weekend and tell me how it goes. I'd love to hear your score, and anything that felt off. Have fun with it.

@austin_buhl Hey, If someone else needs to review, approve, or pick up where I left off, how does Salestrics Resolve Beta handle that handoff?

@austin_buhl Incredible work! Congratulations.

@thamibenjelloun Resolve is optimized for customer support, not just email. HubSpot + Gmail can work for basic support, but Resolve adds structured ticket management, SLAs, customer history, internal collaboration, and AI-assisted responses in a dedicated service platform. The goal is to help teams resolve issues faster and manage support operations with the visibility you'd expect from a Service Cloud-style system.

@austinbuhl Keep up the great work!

@priya_kushwaha1 Great question. There isn’t a single workspace-wide kill switch, yet.

Today Weavz controls the blast radius at the action layer: workspace-scoped access, enabled actions per app, Human Gates that can be rejected/canceled, and cutting off connections/API access so future tool calls stop.

If the agent runs in your own runtime, killing that process stays there. Weavz governs what it can do inside customer apps.

@elias_motionfy This is the right read, and the MotionFy auth pain is painfully familiar. Every provider has its own idea of scopes, refresh, and what a connection even is, and you only feel how bad it is once you're doing it per customer.

Strong agree on the audit trail. Your line nails it, without it you're debugging what you think the agent did, not what it actually did. We log every action with the workspace, the end user it acted as, the inputs, the result, and the approval if it passed a gate, so a run is reconstructable instead of a black box.

And Human Gates is the one everyone skips until an agent does something irreversible in prod exactly once. Cheaper to learn it from a comment than an incident.

Appreciate the thoughtful take. Curious what you ended up doing for auth on MotionFy.

@jimmy_benhsu the agent never holds the OAuth token. It calls a scoped action and Weavz resolves + refreshes the credential server-side at execution time, so tokens refresh per action, not at run start. That is why a run can pause at a Human Gate and resume hours later without breaking. On audit: every action is logged with the workspace, the end user it acted as, the action, result, approval, and timestamp, so you get a full per-run trail across every connected app. Happy to dig into revoked-token / re-consent edge cases.

@dipanshu_kushwaha5 that’s exactly the bet. Agents don’t need bigger connector lists as much as they need scoped credentials, approvals, state, files, and audit around the action. That’s what we’re trying to make boring and reliable with Weavz, so teams building agents, copilots, and internal tools can safely connect them to real customer/business apps.

@caadrifr If the underlying app or input shape changes, how does DevGlobe fail before it quietly gives me a bad result?

@jimmy_benhsu 

Your comment is spot on!

To answer you: feel free to download the extensions without any worry: they never access your code or personal data.

The only things that get tracked are: the programming language you’re using, your IDE, your OS and optionally the name of your repo or the file you’re working on.

You appear on the globe simply because the extension detects when you (or your coding agent) are actively writing code. That’s it!

@omri_ben_shoham1 
Thanks for your feedback!

On DevGlobe, users can choose how they appear on the globe. In Classic mode, you show up in the center of your city (never your exact location). In Anonymous mode, you appear in a random city within your country. And in Private mode, you don't appear on the globe at all though you still track all your own stats.

As for tracking, the extensions only send the server the programming language you're using, the time you spent coding between syncs, your IDE or agent, and optionally the name of your repo or the file you're working on.
Plus, everything is fully transparent: the extensions are open source and deployed via GitHub Actions, so anyone can audit the code and see exactly what’s being sent.

If you like the project, we’d love to see you on the globe 🌍

@dhruv_garg2 
Honestly, RescueTime and Rize are both great products.

The reason we started building FocusStack wasn’t because we thought tracking was broken. It was because even after seeing where our time went, we still struggled to stay focused.

Most people already know they’re getting distracted. The hard part is catching it while it’s happening.

That’s why we’re spending a lot of time on focus sessions, distraction blocking, nudges, and helping people protect their attention, not just measure it.

@galdayan 
Fair point. Tracking is a commodity feature now.

Our focus is less on tracking and more on helping users start and stay in a workflow through Focus Stacks. The nudges are currently simple and rule-based, we’re still learning what works before adding more complexity.

@omri_ben_shoham1 I myself had that problem of forgetting to start and stop the timers. I introduced focus apps and distraction app system. When user opens focus apps like Cursor, Figma User gets nudge to start the timer. When user gets distracted or is finished with the work and goes to watch let's say YouTube which is in distraction list user will get that nudge.
Right now, we did not that feedback to make nudging system smarter. We will try something. There is one problem we don't have any user data as all things stay local. If you can suggest any system for it, we would be happy.

@pixelite2030 Honestly, tracking was the easy part.

The harder problem was figuring out how to stop myself from getting distracted in the first place 😅

That’s why we added things like focus sessions, distraction blocking, and nudges when you start drifting away from what you’re supposed to be doing.

The tracking helps you see the problem. The rest helps you do something about it.

At least that’s what we found while building and using it ourselves.

@suraj_prasad9 
Thanks for the thoughtful question. This is actually a workflow we’ve heard from quite a few developers.

Right now, FocusStack tracks apps and websites, but it doesn’t distinguish between individual terminal windows or Claude Code sessions. So if you have five Claude Code instances open for Project A, FocusStack will currently see them all as the same application. For project tracking, you manually select the active project, which works well as long as you’re not actively switching between multiple projects at the same time. In your workflow, where different terminal sessions represent different threads of work, we definitely understand that the current model falls short.

As for catching when you drift from Project A into Project B, FocusStack doesn’t yet have visibility into that level of context inside terminal sessions, so it won’t automatically know you’ve switched projects. That’s something we’re very interested in exploring because it’s a real problem for developers.

On the nudges side, we had the exact same concern you mentioned: most people just dismiss notifications without thinking. That’s actually why our distraction nudges don’t have a dismiss button. If you’re in a focus session and open something distracting, the notification is intentionally a little annoying 😅. The only way to get rid of it is to end the focus session, which feels like a much bigger decision and creates a small moment of friction. We don’t have a dedicated “Are you sure you’re switching projects?” flow today, but I really like that idea. It fits closely with how we think about focus: not preventing people from switching, but making sure the switch is intentional rather than something that happens on autopilot.

@galdayan Thanks — fair point. “40+ tools” alone isn’t the differentiator anymore; it’s table stakes in this space.PDFTools is focused on being a privacy-first, low-friction PDF workspace for people handling sensitive documents like contracts, invoices, IDs, tax forms, client files, and legal PDFs.

For supported tools, processing happens in the browser, so users don’t need to upload files just to compress, merge, split, sign, rotate, protect, or extract text.The switching reason is mainly: no signup, no install, no upload-first workflow, and a cleaner everyday PDF experience. The audience I’m targeting is students, freelancers, educators, small businesses, and admin/legal users who don’t need heavy Acrobat-style software but still care about privacy. Beyond basic tools, I’m working on workflows like PDF diff, batch processing, metadata sanitization, form data extraction, certificate generation, Bates numbering, and search-based redaction. You’re also right about the AI tag — I need to make that clearer. Current AI features are mainly Chat with PDF, PDF table extraction, and PDF to Audio, with summarization and smarter document understanding planned next.

@noah_ben All the files you upload on tools using server upload, you upload your file for some editing and download your edited file but they still have access to your files.

@nanimono_masa Yes, this convert multipages pdf to images and vice versa, It has a lot of more features around 45+, generate QR code on each page of singal pdf, it means you can access a singal page from pdf. I would like if you visit the page, you can find a lot more there and I hope you will like it much.

@nanimono_masa For anyone curious, PDFTools currently includes 40+ PDF tools across a few categories:

Core PDF tools: Compress, merge, split, rotate, delete pages, organize pages, crop, resize, flatten, insert blank pages.

Editing & signing: Edit PDF, annotate, fill PDF forms, e-sign PDF, watermark, add page numbers, metadata editor.

Conversion: Image to PDF, scan to PDF, PDF to images, PDF to Word, Word to PDF, PDF to Excel/CSV, HTML to PDF, text to PDF, PDF to PDF/A.

Security & privacy: Password protect, unlock PDF, redact PDF, metadata sanitizer, encrypted browser vault.

Extraction & AI: OCR PDF, extract text, word counter, Chat with PDF, PDF to Audio, form data extraction.

Advanced workflows: Batch processing, PDF diff, certificate generator, booklet creator, bulk rename, QR code stamp, split by bookmarks, Bates numbering, color inverter, search & redact.

@naimz Great question, and it's one of the most important design calls in the whole product. Short version: yes, but it's deliberately not "anyone."

The value of the credential is that a real, identity-verified person who was actually there went on record. So if a direct manager won't or can't, the candidate can use someone else who genuinely worked with them on that role: a skip-level, a close peer, a cross-functional lead, even a direct report for leadership work. What we won't do is allow a character reference or a friend who can't speak to the actual work, because that's the thing that makes most references worthless.

The credential also shows who verified it (former manager vs. peer vs. report), so it's transparent rather than flattening everyone into one "verified" badge.

Honestly, this is exactly the kind of thing I'm trying to get right, so I'm curious: from where you sit, would a verified former peer or direct report carry real weight for you, or is it really only the manager's word that moves the needle?