PH热榜 | 2026-06-05

@artem_kosilov Congrats on the launch, Just a quick que: when agents operate cross-border, how do you handle multi-currency and local payment method edge cases without forcing the user to manually override per market?

@artem_kosilov How are ad budget limits set?

@maria_anosova Commerce has moved fast since those apples. Thank you for the support. When they try it, we'd want to hear how it lands.

@fberrez1 SellerClaw connects directly via API where it exists, and through browser automation where it doesn't, without a feed aggregator in between.

Inventory and pricing sync runs through the Supplier Agent on that layer. The lag window question across Amazon and Shopify running simultaneously is a fair stress test and worth a detailed answer in the comments here. On channel-specific content: listings are generated per-channel, not from a single template. How Amazon's title length constraints get handled versus Shopify is a good follow-up to press on.

@fberrez1 

Really good question. On inventory sync: yes, we update stock levels across platforms. If someone buys a unit on Shopify and you're running FBM (fulfillment by merchant), the count on your warehouse drops by one everywhere it's listed.

The nuance is your shipping model. If you use a third-party fulfillment provider, that service usually has its own stock-sync layer already. Where SellerClaw really earns its keep is when you ship from your own warehouse and don't have that middleware, our software handles the cross-channel sync directly. And we also have our own fulfillment solution, so if you want it fully connected, we can wire the fulfillment and the agent together end to end.

On channel-specific policy differences: our agents are trained specifically for the requirements of each platform. They account for the full set of rules a given marketplace imposes and adapt every listing to fit them, so the same SKU lands correctly whether it's on Amazon or Shopify. On top of that, we pull from external data sources to build SEO descriptions, not just the marketplace's own algorithms. Today we use DataForSEO on Shopify, and we're rolling out Helium 10 keyword data for Amazon next, so your listings are optimized against real external analytics and have a shot at ranking number one.

@fberrez1 Thank you. We look forward to hearing your feedback 👍

@curiouskitty 
Great question, though worth clarifying which side we're on. SellerClaw is the seller-side agent, it works in place of a marketplace manager (listings, pricing, ads, inventory, customer replies), rather than the buyer-side agent shopping through chat.

That said, the core challenge you're describing, keeping a promise consistent from chat → checkout → delivery, is exactly the kind of thing we're building toward. Our current focus is SellerClaw, but a follow-up product, SellerCart, is designed to address the agentic-shopping side directly.

Even today the same discipline applies on our end: the agent never invents numbers, it reads from the platform when they're needed, inventory stays synced, and settlement runs on the marketplace's own rails. So what the agent promises always reconciles with the system that actually fulfills it.

@curiouskitty Thank you for your support; it means a lot to us.

@curiouskitty Totally agree — keeping the promise consistent end-to-end is the hard part.

On the seller side, I think the biggest operational risk is availability and post-purchase state staying in sync across systems. Totals/tax/shipping can usually be computed deterministically at checkout, but inventory, fulfillment status, cancellations, and returns are where things drift fast if the agent is not grounded in live system data.

Our approach is to keep the agent decision-making layer separate from the source-of-truth transaction layer: the agent can decide and act, but the final numbers, inventory state, order status, and settlement always come from the platform or connected system itself. So the promise is only made off live data, and every action has to reconcile back to the system that will actually fulfill it.

@artem_anikeev 

Glad that resonated, it's a deliberate choice.

We have an advisory mode where the agent asks for your approval before each action. Most people lean on it early, and that's exactly right: like any new hire, an agent needs to be trained and checked before you trust it to run on its own. There's no magic where you flip a switch on day one and money rains down.

Think of it as an upfront investment. You put in a bit of supervision at the start, and what you get on the other side is essentially an employee who then works 24/7, no vacations, no sick days, and does it consistently. You decide when it's earned enough trust to take the wheel.

@artem_anikeev By design. You should see how the agent behaves before giving it more room to run.

@artstavenka1 The browser path exists for channels where there's no API to hit. For those, actions are logged and failures come through as Telegram notifications before the next cycle runs.

When a marketplace ships a UI update that breaks a flow, the agent reaches an error state and flags it. How fast that gets caught depends on how the failure looks. A clean error surfaces faster than a silent wrong-page interaction. We haven't fully solved that and won't pretend we have.

@artstavenka1 Sharp question, and exactly the right thing to poke at.

The browser path only exists for channels that don't expose an API, so it's the fallback, not the default. For those, every action is logged, and failures surface as Telegram notifications before the next cycle runs, so a broken step doesn't just disappear into the void.

When a marketplace ships a UI change that breaks a flow, the agent hits an error state and flags it. How fast we catch it honestly depends on how the failure presents: a clean error surfaces immediately, while a silent wrong-page interaction (the agent "thinks" it repriced but nothing landed) is the harder case. That's the exact gap you're pointing at, and we haven't fully solved it, won't pretend we have. Tightening post-action verification on the browser-driven channels is an active area for us.

Appreciate you raising the silent-failure case specifically. It's the one that matters most and the one most people don't think to ask about.

@artstavenka1 Thank you✨

@davitausberlin The Supervisor agent doesn't resolve this unilaterally. When two agents are pulling in opposite directions on something consequential, it surfaces the conflict for your approval rather than making the call. Neither agent can push through an irreversible action without confirmed context.

You set the budget rails and the goals each agent operates within. Genuine conflicts outside those rules come to you.

@davitausberlin Great question. The short answer: the supervisor resolves it through unit economics, not by picking a favorite agent.

The moment we list a product, we map every non-recoverable cost: category commission, fulfillment and shipping. (Those differ by model, FBA carries Amazon's own fees, while self-fulfilled orders on Shopify or other channels run on USPS, UPS, FedEx, or FBA rates depending on item dimensions and the state you ship from.) Once that full P&L picture is in place, the supervisor knows the allowable ACoS/TACoS and exactly how much of the margin can go to ads.

So in your example, profitability comes first. The pricing and advertising agents don't fight, they operate inside the same economic envelope. The system won't green-light ad spend that pushes a SKU into the red. The one deliberate exception is an investment window, where the supervisor may approve heavier ad spend on purpose to gather early reviews and build organic ranking that pays back later. But that's a conscious call, not an agent winning a tug-of-war.

In short: economics sets the boundaries, and the agents optimize within them rather than against each other.

@dmitry_zakharov_ai Thanks!

@dmitry_zakharov_ai Thanks!

@dmitry_zakharov_ai Thank you, we appreciate your support!

@kn0wn All of the features we’ve mentioned are already live — the main limitation right now is the number of integrations. At the moment you can connect Shopify and eBay as sales channels, Meta Ads and Google Ads for ad platforms, and CJ Dropshipping for suppliers. Amazon is coming in the next 2–3 weeks, and TikTok is on the way as well.

@ponikarovskii Shopify will almost certainly build something. When they do, it'll work well for sellers who live entirely on Shopify. The sellers we're building for mostly don't. SellerClaw runs across Shopify, eBay, and Amazon simultaneously. Same SKU, different rules on each channel, inventory state that has to stay consistent across all of them. A Shopify-native tool doesn't coordinate across those boundaries. I ran a cross-border platform with over a thousand sellers. Most of them were on multiple channels. The hard problems were never inside any single one.

@ponikarovskii Appreciate that, and it's the question we ask ourselves too.

Shopify could ship a native tool, but it would only ever see Shopify. The whole point of what we're building is cross-platform: repricing and sourcing across Shopify, eBay, and CJ in one place. A seller competing on eBay's Buy Box or pulling margin from CJ can't get that from a Shopify-only feature, by definition.

Platforms optimize for their own ecosystem. We optimize for the seller wherever they actually sell. That gap is the business.

@danshipit 

Thanks for the question! Right now it works with our existing set of integrations, eBay, Shopify, and the others, which is fixed for the moment, rather than any arbitrary custom store.

That said, we already have a roadmap of marketplaces and ERP systems we're planning to add soon. And since we're still in active development, we're genuinely open to requests, so if there's a specific platform you'd want supported, tell us. We'd rather hear it now while we can still shape what gets built and tailor solutions to what customers actually need.

What store are you running? Happy to note it down.

@danshipit Beyond the listed integrations, SellerClaw can work through browser automation when an API isn't available. So it's not locked to the platforms on the list. Custom setups depend on what access you can give it.

@artem_anikeev 
Thank you, really appreciate that!

You're touching on something real. Even though the US market is relatively mature in e-commerce, with fairly predictable costs, the global trend is clear: marketplace fees keep climbing, and so do the costs of goods, production, and labor. Margins get squeezed from every direction.

That's exactly the problem we're focused on, helping sellers optimize and stay profitable while the ground keeps shifting under them. The pace of change is only accelerating, and doing things the old manual way gets harder every quarter.

Thanks for the kind words, and good luck to you too!

@artem_anikeev Thank you! The urgency is real. For most sellers it shows up as margin getting eaten by operational overhead before revenue catches up. That's the problem SellerClaw is built around.

@artem_kosilov Now that's what I call a real bonus! Thanks

@maurya_abhiranjan Credits map to work done: small tasks use a few credits, heavier workflows use more. Our examples are ~2 credits for a customer reply, ~15 for a listing, ~40 for market research, and 100 credits = $1. For daily repricing across a few hundred listings, the exact monthly spend depends on how often you run the loop and how much reasoning is involved, but the dashboard shows estimates before big tasks and exact usage after.

@zaid_mallik1 Great question, and you're right that the coordination is the hard part.

We run a supervisor architecture. There's a supervisor agent that owns the shared view of the business and sits above four specialists: Product Scout for sourcing, an eBay manager, a Shopify manager, and an Ads manager. The specialists don't talk to each other directly. The supervisor assigns the work, hands each one the context it needs, checks the results, and resolves conflicts when two of them would otherwise act on stale or competing info.

So there's one source of truth at the top instead of four agents each guessing at reality. The Product Scout finding a SKU, the channel managers pricing and listing it, the Ads manager promoting it, all of that stays in sync because the supervisor is the one coordinating, not the agents negotiating among themselves.

@zaid_mallik1 Great question — we’ve found the same thing. The hard part is usually not the individual agent skills, it’s keeping them aligned on one shared state.

Our approach is to have a supervisor agent coordinating specialized agents. That supervisor manages task routing, shared context, and execution order, while the underlying systems remain the source of truth for things like inventory, pricing, and order state. So instead of every agent maintaining its own view of reality, they operate through a coordinated layer that keeps decisions and actions reconciled.

@rustam_khasanov thanks! Shopify and eBay are live now. Amazon is coming.

@rustam_khasanov Thanks! Shopify and eBay are the main focus right now, so those are fully live. Amazon's next — we've already been granted developer access to the SP-API and we're working on bringing it into the product soon. Stay tuned.

@rustam_khasanov Thanks! Shopify and eBay are the main focus live right now. Amazon support is in progress and should be coming in the next 2–3 weeks.

@veerhunt_agai Thank you for breaking that down so specifically. Pricing is part of the agent scope and you configure what it optimizes for, with guardrails on what it can change on its own.

@veerhunt_agai Yes — it depends on where the competitor pricing lives. If the platform exposes usable pricing data, the agent can pull it via API; if not, it can use browser automation to read prices directly from the competitor’s site.

On the optimization side, the user can choose the target metric, but the default logic is to maximize Buy Box win rate while still respecting the minimum margin threshold set by the user. So it’s not just a one-time suggestion — it can operate as an actual repricing loop within the guardrails you define.

@veerhunt_agai Good question. Short answer: API where the marketplace exposes pricing, browser automation where it doesn't, so you're covered even on platforms that lock their data down.

Default logic targets Buy Box win rate but never below the margin floor you set, and you can switch the target metric per your strategy. It's a live repricing loop inside your guardrails, not a one-off suggestion.

Happy to go deeper on the thin-margin case if useful.

@german_merlo1 Thank you, I really appreciate your support!

@german_merlo1 Thank you so much! You nailed it, running an online store today is still mostly manual, repetitive work, and that's exactly what we're out to change. Really appreciate the kind words and the support!

@malithmcrdev That's the goal. You set what to sell and how, agents handle the rest.

@malithmcrdev 
That's the dream we're building toward :) The way to think about it: you stay the owner making the calls, and the agents handle the daily grind in the background, sourcing, listing, pricing, orders, customer replies. You set the direction and approve the big moves, they do the heavy lifting around the clock. Less running the store, more running the business.

@alena_medvedevaa 
Exactly — the supplier side is what we built the workflow around. The agent runs the full loop: source a product from a supplier into your catalog, list it, and when an order comes in, buy it from the supplier and fulfill it. The part that matters for daily supplier issues: it keeps re-checking supplier stock and prices across your catalog on its own, automatically syncs stock-outs down to your live listings so you don't sell what can't ship, and won't complete a purchase if the supplier's cost has jumped — so price spikes don't quietly eat your margin. Proactively chasing stuck or lost shipments is still on our roadmap.

@alena_medvedevaa Dropshipping breaks in the handoffs more than anywhere else. Supplier stock changes, data goes stale, and by the time an order lands the inventory is already gone. The Supplier Agent stays on top of that layer continuously.

@alena_medvedevaa 
You've both said it better than I could, so I'll just put a bow on it.

Dropshipping doesn't break at the big, visible steps. It breaks in the quiet handoffs between them, the moment supplier stock shifts, a price ticks up, or data goes stale between the order landing and the fulfillment going out. That gap is where margins leak and customers get disappointed, and it's invisible until it's already cost you.

That's the whole reason the Supplier Agent exists: to live in that gap and watch it continuously, so the boring-but-critical work of re-checking stock and prices and syncing it down to your live listings just happens, without you babysitting it. You spotted exactly the pain we set out to kill.

Thanks for getting it, this is the part we're most excited about.

@annmast 
A bit of both, and the image side is growing fast.

Today we have photo sourcing: if you don't have images for a product, we can find them by SKU/barcode across web sources and match them to your listing. Those tend to be the standard white-background factory shots, so think of it as covering the basics.

What's coming soon is more interesting. Based on competitor analysis and the product description, we'll generate proper infographics that highlight the product's unique selling points, sized automatically to each platform's requirements. So not just sourcing an image, but building listing visuals that actually sell.

And the step after that is A/B testing, letting you compare which visuals and content perform best according to the metrics, so the listing keeps improving over time.

@annmast Listing work is primarily text right now: copy, titles, descriptions, structured for each channel. Image editing isn't part of it at the moment. Best way to see what it does: there's a short video on the listing, and if you want to run it yourself, use promo code PH1000 at signup for 1,500 credits free.

@artyom_zhuravlev 
Exactly, that's a big chunk of the daily admin gone.

Worth noting how tracking actually reaches the buyer: on marketplaces, they see status and tracking numbers right in their account, and on Shopify they get the shipping email with the tracking number and an estimated arrival. So the baseline updates are already handled by default.

Where we add value is being smart about what's worth a message. We don't ping the customer at every leg of the journey ("now it's in this state, now the next one"), because that's just noise that ends up annoying people. Instead we notify on the moments that matter, shipped and delivered, plus we flag the exceptions: a tracking number that stops updating, a damaged label, or a cross-border parcel stuck at customs. Those are the cases where the buyer actually needs to step in, so that's where the agent reaches out.

So less routine busywork for you, and fewer pointless notifications for your customers.

@artyom_zhuravlev Exactly — and if you have a dropshipping supplier connected, it can also fulfill orders fully autonomously, which is where it starts saving a lot of real operational time.

@artyom_zhuravlev That's exactly the kind of admin SellerClaw takes off the plate. Fulfillment tracking and customer communication are both covered.

@solodnev 
Thanks! Honest answer: real-world burn rate is something we're still gathering data on as more stores come online, so I won't give you a made-up number.

What I can tell you is how it works under the hood: different operations run on different models matched to the task. Routine, high-volume actions use lighter models, while the more analytical work runs on heavier ones. So credit usage scales with what your store actually does, its size, how much daily routine you automate, how much content gets generated, and so on, rather than a flat rate.

As we get more usage data, we'll be able to share real benchmarks. Great question to keep us honest on.

@solodnev Depends on the workflow. Active sourcing and listing across multiple channels uses more than a store running mainly support. We're on a credit-based model: three plans with larger monthly balances at higher tiers, plus top-up packs if you run over. The 1,500 from PH1000 are enough to run a sourcing-to-listing workflow and see where credits go.

@shepovalovdenis 
Yes. The agents use your existing listings and past customer replies as context, so the tone they produce matches how your store already sounds rather than a generic default. You can also set explicit brand guidelines if you want to steer it further, but the baseline is learned from what you've already published.

@lovik1468 
Not yet, WooCommerce isn't integrated at the moment. It's something we can look at adding soon, though. Right now our focus is on Shopify as the primary platform, alongside the leading marketplaces. Appreciate you flagging it, demand like this is exactly what helps us prioritize what comes next.

@lovik1468 WooCommerce is definitely on our priority list for upcoming SellerClaw integrations. It’s one of the platforms we’d really like to add next.

@andrew_white_13 Advisory mode covers publishing and orders: every action goes to your review queue before anything runs. Budget rails handle ad spend. Margin floors and refund-specific controls are on the roadmap. Appreciated the specifics. That's useful input for us.

@andrew_white_13 
Control is the right thing to anchor on, it's exactly how we think about it too.

Advisory mode is the foundation: publishing and supplier orders both flow into a review queue, so nothing executes until you approve it. Ad spend runs inside budget rails you set, so the agents can't exceed what you've allowed. Margin floors and dedicated refund controls are on the roadmap, the same guardrail logic, applied to those two areas next.

The principle is simple: the agents do the heavy lifting, but you set the boundaries and hold the final say on anything that matters. Really appreciate you spelling out the specifics, refunds, margins, ad spend, publishing, that's genuinely useful input as we build the guardrail layer out.

@konstantin_alkhimov Not Shopify only. Shopify and eBay are live now, with more channels coming. The same agent logic runs across whichever stores are connected.

@konstantin_alkhimov 
Mixed stores, not Shopify only. Here's where things stand right now:

Sourcing / dropshipping: CJ Dropshipping
Sales channels: Shopify and eBay (Amazon and Etsy are next on the roadmap)
Ads: Google and Facebook

And it's not one store per account, you can connect several Shopify stores and several eBay accounts to a single SellerClaw login and run all of them from one window. So if you're juggling multiple storefronts across both platforms, they all live in one place.

@valeriya_vovk That's the core of how SellerClaw is built. Every action is logged with context, so you can see what ran, what changed, and why. For bigger decisions, advisory mode sends them to your review queue before anything goes live. Results come through the dashboard and agent reports, so you're not digging across platforms to understand what's working. The autonomy level is yours to set and adjust anytime.

@valeriya_vovk This is exactly the part we obsess over, and it maps really well to the day-to-day of managing marketplaces.

Every meaningful action comes with its reasoning attached: why a price moved, why ad spend shifted, why a supplier was chosen, all tied back to the unit economics behind it. So instead of manually pulling numbers to justify a decision, you have the "why" already documented. The bigger moves sit behind your approval: the agents propose, you confirm, and you set how much autonomy to hand over.

Where this really pays off in your role is reporting. SellerClaw rolls everything up into integrated reporting you can slice different ways, by channel, by SKU, by ad spend vs. margin, by period. So when leadership asks "what changed and why," you're not stitching together exports from five tools at 11pm. You get a single, defensible view of what the agents did, what it cost, and what it earned, which makes the conversation with management much easier.

Track the results, stay in control, and have the numbers ready when you need them. That's the goal.

@jay_gadekar so excited to have built it alongside you and our team! <3

@jay_gadekar Many congratulations on the launch! :)

Really, really beautiful landing page, so cute, and I love the branding!

Minimi is your ambient memory for Claude, a Mac app that quietly captures everything you do on your computer (every tab, document, call, and Slack thread) and feeds it to Claude as live context.

Instead of manually briefing Claude or hunting through your history, you can just ask questions like "Who sent me the screenshot about the bug?" or "What did we decide in yesterday's meeting?" and Claude will know.

I endorse it because it's 50% more accurate than previous memory systems (54% vs 36% on the BEAM benchmark), keeps your memory on-device in a local vector database with nothing stored on the cloud, and lets you skip the extra prompting to get straight to answers.

This is exactly what AI assistants have been missing, true long-term memory that actually works while protecting your privacy.

@jay_gadekar Congrats! Love the idea, especially that it's ambient (aka frictionless). Sadly, I'm PC - any chance you'll be doing a PC version soon?

@niketrajdwivedi - yup! Proud to have built this together :))

@niketrajdwivedi minimi started with such a small spark - to now see it become an awesome side project. Crazy stuff.

@ozandag Hi Ozan, even @zaid_mallik1 asked me the same question!

Here was my answer:

In Minimi - updates, contradictions, and temporal order are handled as core behavior, not patched on.

It's why we measure ourselves on BEAM rather than the older recall-only benchmarks. BEAM runs at 1M and 10M token scale and can't be solved by a bigger context window, so it directly tests the staleness question.

We're at 54% vs the prior 36% SOTA, with most of the lead on the over-time tasks.

Short version: maintaining an accurate picture beats retrieving more, every time!

@ozandag Anyone can capture everything; the value is in what you choose to surface. We optimize for an accurate picture over raw recall, which is why we benchmark on BEAM and LongMemEval rather than recall-only tests — these run on very long conversations where the retrieval system has to surface only the relevant pieces. And keeping it on-device.

@ozandag We are super accurate with what to surface. The underlying tech of Minimi helps with the accuracy.

@vineet_gupta20 - great job, Vineet :))

@vineet_gupta20 Being local is a big relief!

@tom_palmer_ux - thanks for writing back. When you pause - say for 5 or 10 min, your memory won't be created for that duration. Please feel free to ask more queries. Good day! :)

@tom_palmer_ux thank you for trying out Minimi! Please share your feedback with us soon :)

@tom_palmer_ux By pausing, we don't capture anything from that window from the moment you turn it on

@ojasvika_sahu the gift example — remembering an offhand thing someone said on a call weeks later — is exactly the magic tbh. but if its hearing everythiing, how does it know that one line mattered vs the 99% thats just background chatter? curious if thats tuned or you just store it all and let retrieval sort it out

@ojasvika_sahu  - yup! Proud to have built this together :))

@ojasvika_sahu The usecases are so insane!

@nainabajaj27 Thanks Naina!

@nainabajaj27 Thank you as always Naina <3

@nainabajaj27 Thanks Naina!

@zaid_mallik1 In Minimi - updates, contradictions, and temporal order are handled as core behavior, not patched on.

It's why we measure ourselves on BEAM rather than the older recall-only benchmarks. BEAM runs at 1M and 10M token scale and can't be solved by a bigger context window, so it directly tests the staleness question.

We're at 54% vs the prior 36% SOTA, with most of the lead on the over-time tasks.

Short version: maintaining an accurate picture beats retrieving more, every time!

@zaid_mallik1 Hope Ojasvika's answer has clarified your question. Feel free to ask if there's anything else, Zaid.

@zaid_mallik1 Really the right question - and honestly the harder engineering problem. Retrieval is mostly solved. Accuracy over time will need more work.

The way we think about it: Minimi captures chronologically, so context has a timestamp. Claude can reason about recency - what you discussed last week vs last month - rather than treating everything as equally current. We're also working on explicit memory updates, where newer context can surface and deprecate older facts.

The bigger unsolved problem is knowing what you consider still true. That's more personal signal than technical - we're exploring ways to let users flag it directly.

@dynatrading Hi Andy - the infrastructure we rely on - Accessibility - is not currently reliable for Windows, thus we have not gotten around making a windows version.

However building ambient memory for Windows is something we are absolutely going to get on very soon!

@dynatrading  We went Mac-first to get the capture quality right every app, zero integrations, completely passive. Replicating that on Windows takes time to do properly.

@dynatrading Hopefully soon, Andy!

@jessica_w204 - glad to hear. Please feel free to reach out any time. Good day! :)

@jessica_w204 Looking forward to your feedback!

@jessica_w204 Love to hear it Jessica would love your feedback once you've tried it

@divyansh_shourie Hi Divyansh! Thank you for your kind words - looking forward to hearing your feedback on Minimi :)

@divyansh_shourie - thanks Divyansh :))

@divyansh_shourie Thank you, Divyansh!

@artstavenka1 - great question, and you're right to push on this. When you block an app or domain, Minimi stops capturing from it going forward. Revoking or pausing fully stops all capture.

On deletion - you can't yet delete specific memories granularly, but a full app uninstall wipes the local store entirely, vectors included. Selective memory deletion is on our roadmap.

Keen to hear your feedback once you've tried it.

@artstavenka1 Great question. It stops creating memory after you pause Minimi or block an app. The earlier memory stays but we are planning to allow selective deletion.

@kritarthmittal Thank you for trying out Minimi Kritarth! Really appreciate your support!

@kritarthmittal - thanks Kritarth - for always being a true believer in us. Hope you enjoy Minimi :)

@kritarthmittal Thanks, Kritarth!

@suhasmotwani Thanks as always Suhas! <3

@suhasmotwani - thank you! Do try using and share more feedback :)

@suhasmotwani Thanks Suhas!

@nikhilsheoran - thank you! Do share feedback :)

@nikhilsheoran looking forward to hearing your feedback!

@nikhilsheoran Thanks, Nikhil!

@dhanishta_likhar  - yup! Proud to have built this together :))

@dhanishta_likhar those daily reports you create via minimi are so awesome!

@dhanishta_likhar It indeed feels like Jarvis!

@vikrambhandari thank you Vikram - looking forward to hearing your feedback on Minimi :)

@vikrambhandari - thanks Vikram :))

@vikrambhandari So glad! Your feedback has helped us a lot!

@dhiraj_patel5 yes yes! You can exclude apps!

@dhiraj_patel5 Yes absolutely! You can block apps as well as websites.

@dhiraj_patel5 - yes, you can block apps to not make memory from on your Minimi home page :))

@prannay_kedia your initial feedback was critical for us to build ahead. Thank you for supporting us so early on!

@prannay_kedia - thanks Prannay for being amongst our earliest users!

@prannay_kedia Always glad to have your feedback, Prannay!

@curiouskitty - the bet is on zero friction.

Manual notes and curated workflows ask you to decide what matters in the moment. Which means you're one busy day away from a gap. Most people don't take notes on the tab they skimmed or the offhand thing mentioned on a call - but that's exactly the context Claude ends up needing.

Ambient capture removes the decision. You don't curate, you just work - and Minimi builds the picture in the background.

Intentional memory is great for things you know you'll need. But most context isn't that - it's just ambient. That's the gap.

@curiouskitty Manual/Curates memory/workflow will miss out on things by default. Humans aren't perfect and hence Minimi ambiently capturing everything helps.

@arunabh_dastidar The focus on auditability and source-backed outputs is really compelling, especially for high-stakes investment decisions. How do users typically challenge or validate Leni's conclusions when they disagree with them? Awesome work on this!

@arunabh_dastidar "In high-stakes work, 'mostly correct' isn't good enough." — this hits the nail on the head! 🎯 Standard LLMs are great for brainstorming, but relying on them for millions of rows of investment data is a different story. Incredible to see Leni ranking at the top for resistance to hallucinations. Congrats on the launch, Arunabh! This is exactly what the financial and back-office world needs. 🚀

@devanandb thank you! Devanand, really thoughtful questions. Let me answer in two parts.

1) “Model-agnostic routing”: how does Leni decide which LLM handles what, and does the user have a say?

At a high level, it’s more dynamic than “one model for math, one model for writing,” but we do use that spirit (specialization) under the hood.

We use a planner/executor architecture:

Planner: breaks your request into a typed step graph (for example, “retrieve the right source data,” “compute and reconcile numbers,” “write the memo,” “validate outputs”).

Executors: each step is dispatched to the best “worker” for that job, which can be a different model (or tool) depending on the step’s requirements (reasoning depth, speed, cost, strictness, context window, etc.).

Results flow back to the planner, which can adapt the remaining plan based on what came back, including running verification passes.

So yes, it’s task-aware, but also context-aware and adaptive step-by-step, not a static mapping.

On user control, we do both:

For most people, it’s behind the scenes with a strong Auto default (so you don’t have to become an LLM ops engineer).

But we also believe enterprises should be able to standardize on approved models/providers, and in some cases force routing constraints for compliance, security, procurement. The workflow should not change when your firm’s model policy changes.

2) How did we get the first institutional customers to trust AI with real money decisions?

You’re exactly right: trust is the cold start problem.

The honest answer: we didn’t start by asking anyone to “trust the AI.” We started by earning trust operationally, in a few deliberate steps:

Start where the pain is high but the blast radius is controlled

Early use cases were time-sink analyst work (data pulls, consistency checks, first-pass drafts, reconciling numbers across sources) where the team could still review outputs quickly.

Win on verifiability, not vibes

Institutions don’t care if the answer sounds smart. They care if it’s right, and if you can show why. So we focused on:

deterministic data retrieval from their systems,

explicit calculations,

consistency checks,

trust-building behaviors like surfacing assumptions and tying outputs back to source artifacts.

Meet them where their data already lives, and keep it secure

A lot of early trust came from being able to operate inside the reality of institutional stacks (property management, reporting systems, deal docs, models) and being clear on security boundaries (no cross-client leakage, no training foundation models on client data, etc.).

Expand scope only after repeated “no-surprise” outcomes

Once teams saw the same level of quality across multiple cycles (monthly reporting, portfolio monitoring, underwriting support), they naturally moved from “low-stakes” to “real decisions,” because the system had already proven it could behave like a reliable analyst.

So no single customer “went all in” on day one. It was more like: prove accuracy, prove security, prove repeatability, then scale.

If you want, I can share a concrete example of what a routed step graph looks like for something like “build an IC memo, tie-out numbers to the model, generate a lender-ready package.” That tends to make the routing concept click fast.

@arunabh_dastidar  @devanandb Firstly, love this question, especially the second part. On getting the first enterprise customers: honestly, there was no magic trick. It was hard.

A few tactical things helped us early, though. We leaned on our network, started with people who already trusted us as operators/founders, and were very clear about expectations. We didn’t go in saying “trust AI with million-dollar decisions on day one.” We positioned it more as: let us help with the painful, repetitive work first.

We also made a deliberate choice to pursue a few more respected institutional names early, even though those cycles were harder. The thinking was: if we could earn trust with sophisticated teams first, it would create confidence for everyone else later.

@gaurav_madani05 wait does it actually remember a project's context over time, or does every question start from a cold search? been burned by "knowledge" tools that forget everything the second i close the tab

@gaurav_madani05 Really excited to see Leni pushing the industry in this direction. Congrats on the launch!

@gaurav_madani05 Congratulations, Gaurav! Excited to see Leni bringing a new perspective to how teams work with information and make decisions.

@curiouskitty Great question. We treat both decision traces and the private context graph as versioned, auditable artifacts, not “free-form memory.”

1) What gets stored (and what doesn’t)

We store evidence + decisions, not guesses: extracted facts (with source pointers), intermediate calculations, and the final outputs/claims.

We also store the reasoning structure as a trace (what was considered, what was ruled out, and the assumptions made), but we don’t blindly promote it into reusable “truth.”

Anything that’s low-confidence, speculative, or user-specific can be tagged as ephemeral (session-scoped) vs. durable (approved to persist).

2) Preventing bad assumptions from becoming institutional memory

Every node/edge in the graph carries provenance + confidence + freshness (where it came from, how sure we are, and when it was last validated).

Nothing becomes “institutional” without a gate: either explicit human approval, or repeated confirmation across independent sources / repeated workflows.

We use contradiction detection and “challenge” steps: if new evidence conflicts with something previously stored, we don’t overwrite silently — we create a fork / flag and force reconciliation.

3) Handling changing definitions (NOI, occupancy, same-store) across teams

Definitions are treated as first-class, versioned objects (basically a “semantic layer”): NOI_v1, NOI_v2, etc., each with its formula, inclusions/exclusions, and scope (fund, asset class, team).

Any metric in the graph is linked to the definition version used at the time. So historical analyses remain reproducible, and you can re-run with a new definition intentionally.

Cross-team alignment is done via mapping + governance: you can declare “Team A NOI” ↔ “Team B NOI” with explicit deltas, rather than forcing a single ambiguous field.

Net: the system behaves more like an audit-grade knowledge + semantic layer with controlled memory persistence that's transparently shown to teams, versioned, and reversible.

@grover___dev Great question. I think about this every day - Leni’s governance protocol is a set of technical controls that keep outputs accurate, bounded, and auditable in real investment workflows:

Access & action controls: role/permission-based data access plus strict tool allowlisting so the AI can only take approved actions within defined scopes.

Provenance by default: every output carries traceability to the exact source documents/data (and versions) and the extracted fields/mappings used.

Deterministic math: financial calculations run in a controlled execution environment so numbers are reproducible and inspectable, not guessed.

Verification gates: outputs must pass consistency, definition, and reconciliation checks before they ship; if evidence is insufficient or conflicting, the system surfaces the gap instead of improvising.

Definition governance: key metrics and underwriting/reporting conventions are encoded as explicit definitions/rules so the system uses institutional meaning, not generic interpretations.

Closed-loop feedback governance: users correct issues in-line; feedback is structured into error types and updates the context graph + verification layer to prevent repeat errors over time.

Auditability & evaluation: end-to-end logging of inputs, sources, computations, and verification outcomes supports audits and continuous quality measurement.

@grover___dev this is exactly the layer that gets interesting after source traceability.

A source link shows where a number came from, but why a team accepted the assumption, who reviewed the risk, or what changed between the first memo and the version that went to IC.

The way we think about it is that the trace has to capture more than evidence. It should capture the decision context around the evidence: accepted assumptions, open questions, reviewer notes, definition versions, and the point at which a flagged item moved from “needs review” to “approved for use.”

In underwriting, for example, a market rent assumption might be supported by comps, but the insight relies on why the team chose one comp set over another. That is a part absolutely worth preserving, because it is what people come back to later when a deal changes, a lender asks a question, or the next committee wants to know how the conclusion was formed.

And you can have that answer at your fingertips, it's just one ask away.

@tom_palmer_ux thank you! Tom, really appreciate that, and +1 on “retrieval/extraction before generation” being the right instinct for finance.

On conflicts: Leni surfaces the discrepancy first rather than silently picking a winner. When two sources disagree, we:

Show both values side by side, tied back to the exact underlying excerpts (and source docs) so you can see why they differ.

Run a verification step that tries to explain the conflict (for example, timing/cutoff dates, pro forma vs. actual, consolidated vs. property-level, unit mix changes, definition mismatches like NOI vs. NCF, etc.).

If it’s resolvable with clear rules/evidence, we’ll propose a recommended resolution (with rationale + trace). If it’s not, we’ll flag it as “needs human judgment” and let you choose which to carry forward (or keep both with a note).

Arunabh  @tom_palmer_ux the important thing here is that we don’t think resolution should always mean the system picks one number and moves on. In finance, two conflicting numbers can both be “right” depending on context. One might be from the latest model, another from a signed operating statement. One might be actuals, one might be budget.

So the first job is to make the conflict obvious and explain why it may exist. Then, where there is enough evidence, Leni can recommend which number to use and why. But if the conflict requires judgment, we’d rather surface it rather than hide it behind a confident answer.

Arunabh  @tom_palmer_ux 

Thanks Tom! We appreciate it!

This is one of the exact places where finance workflows break if the AI tries to be too clever. We don’t want the system to hide disagreement. Surfacing the conflict is often more valuable than forcing a single answer too early.

@arunabh_dastidar  @thisiskp_ I see amazing comments and feedback, and we are not half way through the day yet!

Keep them coming, guys!

I'm having the time of my life answering all these questions 🧐

@lakshminath_dondeti - its free to try once you are in you can see all the plans starting at $25 a month.

Great question, Thami. The biggest opportunity we're seeing is investor reporting and market research, the work that drives sound investment decisions. That's where scattered, uncited data costs the most, and where verified, source-backed output changes the game. Acquisition memos and underwriting matter too, but reporting and research are where teams feel the lift first.

Thanks@thamibenjelloun! The thing we’ve seen is that reporting (internal or external) tends to be a great wedge because it's recurring, painful, and very easy to judge. When Leni helps a team pull together a cleaner investor update, explain portfolio movements, cite the right sources, and catch inconsistencies before the meeting, the value is realized immediately.

@thamibenjelloun I’d add one reason reporting tends to be a strong early use case: it repeats.

An acquisition memo may be high-value, but reporting creates a cycle where the same team has to explain performance, variances, leasing movement, capex, occupancy, budget vs. actuals, and portfolio changes again and again.

When Leni helps carry forward the structure, pull the right sources, and show what changed since the last period, the workflow improves each cycle. That repeatability is where teams start feeling the lift quickly

@ye_tao1 thanks for being the integral part of the journey.

@ye_tao1 really appreciate you saying this, and thank you for being part of that foundation!

@manuelabarcenas Thank you!!

Appreciate it,@manuelabarcenas!

@manuelabarcenas thank you!

@fberrez1 thanks and great pushback. You’re right that for others “most accurate AI for finance” claims usually collapse as soon as you introduce (a) multi-period reasoning and (b) conflicting sources.

Here’s what we mean, concretely:

1) Benchmark, baseline, query types

We benchmark on investment workflow tasks, not generic QA. These are multi-step jobs that require retrieval, extraction, and deterministic computation across periods. Examples include roll-forwards, bridge analyses, same-store calculations, covenant and debt schedule math, lease abstraction, and memo reconciliation across multiple documents.

Baseline is frontier LLMs + standard RAG. Those stacks are strong at summarizing, but they tend to fail on exactly these tasks because they silently fill gaps, miss constraints, or do “plausible math.”

2) Why our accuracy claim holds (and why it doesn’t break on multi-period / reconciliation)

We don’t treat the LLM output as the final answer. Leni runs a separate verification step using our own verifier models trained on 31k+ decision traces, built specifically to check outputs for inconsistency, missing evidence, and violated constraints.

For numeric work, we use a deterministic math engine so calculations are executed and reproducible instead of “LLM arithmetic.”

3) What happens when sources disagree

When filings, models, memos, or third-party data conflict, Leni does not choose one silently. We:

surface the conflict explicitly (what differs, by how much, and where it came from)

keep provenance down to the exact source artifact (document section / table / cell where possible)

apply policy-driven resolution if the customer configures it (for example “audited overrides unaudited,” “newer period overrides older,” “filing overrides deck”), otherwise we flag it as requires review and route it as an exception

Benchmark coverage (third-party writeups)

https://briefglance.com/articles/niche-ai-platform-leni-outperforms-openai-google-on-key-benchmarks

https://www.wallstreetmojo.com/leni-benchmark-results-financial-research/

https://dupple.com/blog/how-leni-beat-genspark-and-manus-on-gaia-benchmark

Net: the claim is not “we have a magic model.” It’s that we built the workflow so the model cannot get away with being plausibly wrong, especially on the multi-period and reconciliation cases you mentioned.

@fberrez1 one more way we think about accuracy: it has to hold at different layers of the workflow.

There is extraction accuracy, calculation accuracy, reconciliation accuracy, and delivery accuracy. A system can be strong at retrieval and still fail when the answer depends on tying a debt schedule to a model, or reconciling actuals vs. budget across periods.

That’s why we care about benchmarks that test different failure modes: GAIA for long-horizon task execution, SpreadsheetBench for cell-exact Excel work, Bullshit Benchmark for rejecting false premises, and DRACO for research quality. The common thread is whether the system can be checked at each step.

Please test it hard and let us know your feedback! :)

@zain_nj The Product Hunt community is in for a treat. Congrats!

@zain_nj I like everything that I’m reading. I’m impressed that Leni is going after the unsexy part of investment work. Everyone talks about AI writing memos faster, but the painful part is usually before the memo: checking if the rent roll matches the model, figuring out which version of a file is current, catching when a number moved between reports, and making sure nobody is building a conclusion on the wrong assumption. If Leni can make that part easier to inspect, that’s genuinely useful. Congrats on the launch!

@ashamplifies - thank you, my man!! We're here to hear every feedback and suggestion!

@ashamplifies - Thank you! And Leni is all yours to use and abuse, would love for you to try it and share your feedback :)

@ashamplifies thank you, really appreciate it!

Commercial real estate teams were very clear with us about what “accuracy” means for them: numbers that tie back, assumptions that can be reviewed, sources that are easy to inspect, and outputs that hold up when someone is making a real decision.

We listened, built for that standard, and then challenged ourselves to take it further across spreadsheets, research, and reporting workflows.

Excited to have Leni live and get feedback from people outside our usual real estate and investment circle too!

@suryansh_tiwari2 Thank you!

Biggest challenge was getting reliable accuracy under real-world messiness, then making that reliability provable. Accuracy and auditability are tightly linked: you need strong extraction/reasoning, plus verification checks and traceability so an investor can see what drove the answer and where it came from.

The “comfort relying on AI” part comes last in our experience. Once the outputs are consistently correct and explainable, trust follows.

@suryansh_tiwari2 I’d answer it a little differently: the hardest part was teaching the system when to stop.

In investment work, the dangerous failure mode is not always a bad final sentence. It is an earlier assumption that slips through and then infects the model, memo, market read, or reporting narrative downstream.

So a lot of the product work went into decision boundaries: when should Leni continue, when should it ask for a missing input, when should it run a check, and when should it say “this needs review”?

That is also why benchmarks matter to us. The useful test shows whether the system can complete multi-step work and still be checked.

This writeup covers some of that: https://dupple.com/blog/how-leni-beat-genspark-and-manus-on-gaia-benchmark

Comfort from users comes after they see that behavior: the system knows when the answer is not ready yet and will flag it.

@arunabh_dastidar  @millwiller this is one of the hardest parts of applying AI to M&A.

The system has to treat source quality as part of the job. In a real data room, the CIM, QoE, model, exports, and management deck may all be “official” in different ways, but they may not agree.

So Leni should first build a source map: what file says what, which period it refers to, whether it reconciles to the model, and where the breaks are.

If revenue by customer does not tie to the financial model, that should become an exception to resolve, not a part of a confident summary.

That is also why we obsessed with benchmarks around grounded research and spreadsheet execution.

The output has to be checkable across documents and calculations, especially when the source package itself is imperfect:

https://briefglance.com/articles/niche-ai-platform-leni-outperforms-openai-google-on-key-benchmarks

@millwiller Totally agree. In mid-market private M&A, the hardest part is often not the model, it’s the messiness of the source layer.

Where Leni does well is treating “data quality” as a first-class problem, not an afterthought:

• Provenance + traceability: we keep citations back to the exact source snippets used, so you can see what the system relied on and where it came from (and quickly spot when a source is wrong or outdated).

• Discrepancy detection: when multiple sources disagree (or values don’t reconcile), we flag it explicitly rather than forcing a single answer. You get a “here are the competing values + confidence + why” view.

• Missing/partial data handling: we’ll return structured outputs with gaps clearly marked, plus a list of the specific fields and documents that would resolve the gaps (vs. vague “need more info”).

• Efficient correction loop: the practical win is that once you correct or confirm a value, that resolution becomes a reusable context for the next deal and next report, instead of re-litigating the same discrepancy every time.

Net: the goal isn’t to pretend the bottom-of-funnel data is clean. It’s to (1) surface what’s unreliable, (2) quantify the uncertainty, and (3) make the “fix” workflow fast and auditable.

If you have a concrete example (e.g., NOI, rent roll, debt schedule, capex history) where sources commonly conflict, I can tell you how we typically set up the checks and the correction flow for that pattern.

@tanjum Thank You, Tanjum.

@1mirul - Thank you!

@veltrixms Wow, congratulations on the launch!

@veltrixms I'm proud to be a part of Velrix! Thanks Guys!
Thanks @Product Hunt !

@bohdan_sitar Thank you, Bohdan! It's an amazing feeling indeed. Thanks to all early testers!

@nazar_parashchuk Thank you, Nazar! Congrats!

@roman_zayac Thank you, Roman! So excited!

@fberrez1 Hi Florent! Thank you for the support and such a good question! Yes, we've built Veltrix specifically as a copilot which proactively surfaces your data to flag what changed, what looks unusual, any anomalies, any duplicated charges, good/bad trends, and what may need checking. It will show you everything even before you ask a question!

You can connect to QuickBooks, Xero, HubSpot, Shopify, Square out of the box - all using official real-time integrations. We're rolling out more integrations in the next weeks, including Google and Microsoft Workspaces to talk to the data living there.

And lastly - Veltrix can handle messy data perfectly. You can drop any csv, xlsx or pdf - Veltrix will process everything and make it ready for analytics or any your questions. No need to spend time consolidating data - just drop whatever you have.

Give it a try, and let me know what you think. Excited to see your feedback!

@oleksandr_drohomyretskyi2 Thank you, Oleksandr! Can't wait as well. All the feedback so far been amazing and critical, which is a blessing.

@_mkcd_ Thank you, Mark! Absolutely, now we can finally say no to 'finance headache'. I'm so proud of Veltrix, a product that can truly help startups, businesses and anyone working with finances. Finally, we can focus on what matters, and not spending time trying to make sense out of numbers.

@a_bryant Hi Angela! It's instant for any of the integrations (QuickBooks, Xero, HubSpot, Shopify, and more). We're using official real-time integrations, so the data is ready for the use right away. Moreover, Veltrix will surface all the data first and show you a proactive overview, including any anomalies, duplicates and action items! If your data lives in files or Google Drive, then the data processing will take a minute or so. Please, give it a try and let us know what you think!

@nata_sv Thank you so much, Nata! Yes, you can. We have multi-workspace management and you can invite team members too. So, definitely - yes.

@mykola_svystun Thank you, Mykola! Glad to have you on the team!

@maksym_shcherbakov1 Congrats! And it's also all in real-time. Anytime you ask, it's always based on your actual data right now. Amazing work!

@alexkhlystova Thank you, Oleksandra! Yes, Veltrix proactively surfaces your data to alert highlight any critical changes in cash.

@pascal_weinberger Thank you, Pascal! I appreciate the support!

@sara_spanger Hi Sara! Can't agree more. And we felt dashboard fatigue with our first launch as well. Dashboard can only tell you much, why not just go straight to the answers? Glad you like the concept:)

When you connect to QuickBooks, Veltrix will instantly show you what's happening right now. If you need any historic data or trends - just ask a question. It has a power of directly querying your QuickBooks data, so there is no limit on how far it can go.

And yes! We're already thinking on solutions for Veltrix on the go. Will be announced soon!

@oksana_ch Thank you, Oksana!

@dima_kulaksyz Thank you, Dima! It all depends on what setup you have in your sources. Veltrix will use and analyze everything you have connected consolidating multiple currencies and accounts. We do recommend to have one workspace dedicated to one location or business, and switch between others.

@dhiraj_patel5 Yes, exactly! Thank you for the support, Dhiraj!

@marianna_tymchuk Thank you, Marianna! Glad you like it!

@nikitaeverywhere Thank you, Nikita! That is a great question. What I would say is different:
- We're using a set of different models, each for the things they do best.
- We're proactively surfacing your data even before you ask or know what to ask to show you what's going on, what needs your attention and what to do about it.
- We built it specifically for small businesses: it takes a minute to set up, you don't need to know what is MCP, and you just focus on what matters most - your financials.
- We have specific systems in place to accurately save, ingest, query and analyze any data source in real time.
- Lastly, you can connect all your sources in your private workspace, including the integrations Claude currently doesn't support.

Let me know if you have any other questions! Thank you for the support!

@rohanrecommends Appreciate the hunt!

@ada_johnsen (I work at Ideogram) Yes! And btw: a good workflow is to generate something with natural language first to get some layouts you like (the natural language prompts get turned into structured json), then use the power of the structured json if you want to tweak copy/layout

@rohanrecommends  @tom_palmer_ux (I work at Ideogram) Bounding box is not pixel perfect adherence, but it is pretty close

@1mirul Yes! It's all about how the models perform for actual real-world use cases. Appreciate the well wishes, excited to get this out to our community.

@monir_ Really appreciate the thoughtful comment! We're very excited to bring Agent Mode, and the Agent Arena leaderboard to the public to help better measure agentic AI!

@elliott_gluck let's gooooooooo

@dhiraj_patel5 great question – the agent's actions are limited to a sandbox environment at the moment.

@nathan_tran2 Thank you Nathan, super exciting to hear you're already getting value and loving using the product!!

@nathan_tran2 very kind of you, thank you!

@odeth_negapatan1 next up is: Github integration, full stack coding, slide creation, pdf creation, image edit, video gen, and wayyy more. Strap in 🤘

@zaid_mallik1 we see a couple things
1) Most users start messages by handing over a whole job rather than asking for advice: the delegation posture skews heavily toward "build this deliverable" and "operate autonomously." However, after seeing the first response, they tighten the reins — pulling control back far more often than they hand over more.
2) We also find that when the opening ask bundles several explicit parts, agents usually cover all of them; the typical shortfall is leaving one incomplete. A rarer but more consequential shortfall is covert: the agent could have surfaced the incomplete work, but instead presents the result as complete. We call this "Bluffing".

More info here in our blog about the Agent Leaderboard if you're curious: https://arena.ai/blog/agent-arena-methodology/

@huisong_li Thank you @huisong_li , appreciate your support!!

@busmark_w_nika I loved the idea of this product, too. I'm tired of seeing AI slop on Pinterest when I'm looking for inspiration for a project, but the same question popped in my mind, too. Apart from the business making money. But the In-app shop sounds like good for the users of this product to monetize content.

@busmark_w_nika we are planning to monetize through commerce, not ads so the incentives stay aligned with users

@manas_khandelwal2 Idea seems cool! I have been using Pinterest for years and been affecting the search experience. However, What's your thought about scaling Moodloom? isn't it going to be expensive when it comes to handling a massive data?

@ishika_meena That was exactly the thinking behind it! Switching costs are the biggest reason people stay on Pinterest even when they're frustrated. Really glad it worked for you, hope you enjoy Moodloom!

@evakk Thanks Evak! Love the idea of granular levels. The "show only clearly labeled AI" tier is tricky in practice though because it relies on creators self-reporting, and a lot of AI-generated content gets posted without any disclosure. That's actually why we went the detection route instead of trusting tags. Category-level filtering is something we've thought about and could definitely see on the roadmap. Appreciate the thoughtful feedback!

@akin_kevin Thanks for pointing this out, Kevin. When we set up onboarding, we missed that a few interest thumbnails were AI images. I've checked and only a handful are affected. We're swapping them out for non-AI ones.

@curiouskitty Good question, Tbh there's no guardrails as such being implemented yet. There's no confirmation step before clicking. We have retries for tool calls that uses shell commands. So it runs, checks the output and will try a different approach if it get non desired output. Retries several times then provide feedback if still not able to perform the action.

@igorgurovich Oh, thats a solid use case.

To answer your question "on older or lower-spec Macs", the gap is noticeable, I haven't tested myself but on M1 with 16 gb ram with nothing else running, the latency should be under 3-5s for a normal command, but for complex commands like generating some health report, it can take a while. Yes latency has been a concern but I was earlier looking into possibility of distributed computing just like how torrent works, offloading compute, but couldn't make much progress there :)

@curiouskitty 

Thanks for the thoughtful question! 🐱

The philosophy was simple: the viewer should disappear, and you're just looking at your image — but when you need to dig deeper, one keystroke brings up any pro tool instantly. No menus, no panels, no chrome. Just the image.

Scope decisions were driven by our own daily workflows — EXIF and histogram for photography, OCR and color tools for design/development work. Every feature has a single-key shortcut: H for histogram, ⌘I for EXIF, T for OCR, C for color picker, P for palette, W for compare. They appear when you need them and vanish when you don't.

The surprise hit? Color palette extraction. We expected EXIF to be the main "pro" draw, but designers and devs consistently tell us they love hitting P on any image and getting a usable 6-color palette they can copy in HEX/RGB/HSL. It turned FloatPic from "nice viewer" into something people keep open all day as a reference tool.

@madalina_barbu Thank you for the kind words! Highly appreciate the support.

@fberrez1 
Great observations — those are exactly the edge cases we focused on.

Spaces: FloatPic panels use canJoinAllSpaces, so each floating image appears on every desktop/Space automatically. Combined with the optional floating-on-top level (togglable in Settings), the image genuinely stays pinned above your work regardless of which Space you're on.

Multiple images: Currently FloatPic uses a single-panel approach — opening a new image replaces the one in the existing floating window, and you navigate between images in the same directory with swipe or arrow keys. This was an intentional tradeoff: for the "pinned reference image" workflow, one clean floating frame is usually what you actually want. That said, we're actively considering multi-panel support for scenarios where you need two images visible side-by-side (and the compare mode already handles that for images in the same folder).

Fair point on where minimal viewers fall apart — we'd rather do one window really well than half-support a feature that creates the stacking chaos you described. Appreciate the thoughtful feedback!

@imoluuu great question! It watches on page load and for mutations on the page.

We’re adding an option for controlling whether it watches on inactive tabs (in case you’re using chat on pages that aren’t currently visible, but could sneakily swap out content when you’re not looking).

@curiouskitty Great question! For us, token efficiency is a secondary benefit. Our primary focus is on prompt injection, dark patterns, and context pollution that can compromise the agent or make them fail at the task.

Because it's a normal browser extension, you can use it inside your token-efficient agent browser

@grace_lee26 absolutely - the security is important but the token saving is a super sweet benefit.

That’s a fantastic point about the diff. We don’t have that at the moment but that would be a great feature. Would you expect to see that in console logs or where would you want that output of the diff sent?

Thanks for the support!

@christian_knaut Currently rules-based. We're working on adaptive patterns, but to determine what should be run on device (which might be a low-resource VM) vs. supporting external injection detection APIs

@marianna_tymchuk Thank you!

@veltrixms Thanks, and good luck to you!

@igorgurovich I love that application for aging parents, Igor. In my experience building out these workflows, the longer the call, the harder it is to avoid that 'robot moment.' Most of my pilot testing so far has been focused on shorter, highly qualified meeting booking flows where the emotional control performs beautifully. I actually haven't pushed a single session to a continuous 10 minutes yet, so I'm incredibly curious to hear the makers' answer on how the prosody holds up at that length. Tagging the team to chime in!

@nicholas_trajeco will definitely give this a shot, thanks

@nicholas_trajeco P.s. I'm having a lot of trouble clicking any buttons on your website due to the animations, maybe I'm just a boomer ¯\_(ツ)_/¯

https://studio.lumotechnology.com/

@busra_seker1 Yeah this was honestly the main thing we obsessed over, because we ran into the same problem with every other tool we tried. The draft looks fine and then you spend an hour fighting with it.

So with LUMO you're not stuck with whatever it gives you.

After it generates, you go into a proper canvas editor and can actually move stuff around, resize things, change the layout, swap images, mess with fonts and colors, fix the spacing, whatever you need.

You can also change the overall style and it'll update the whole deck so it stays consistent instead of you fixing every slide one by one.

Or if you don't feel like dragging things around, you can just type what you want changed and it does it.

Basically the first version comes together fast but you've still got full control after.

@sasha_mcclendon 

No template needed at all, you can bring your brand in directly. There's a Style Guide section where you can either upload a brand guidelines PDF, drop in some inspiration images, or just paste your website URL and it'll pull everything from there.

It reads your site and builds out a full brand kit, so it grabs your colors with the actual hex codes, your fonts, logo and brand images, even picks up on your brand values and tone.

Then that becomes the style your decks are built on, so you're not starting from a blank template and trying to recreate your brand by hand.

So short answer, you can import guidelines OR just point it at your site, whichever's easier for you.

@marianna_tymchuk It's the thing we think about most. The automation works inside your brand, not instead of it, so it builds within your saved brand kit (colors, fonts, logo, tone) rather than inventing a new look each time.

The repetitive stuff gets automated, like layout and structure, but the identity stays yours, and since every deck pulls from the same brand kit they stay consistent with each other.

Then you can fine-tune anything in the canvas. Automate the busywork, keep the brand front and center.

@scott_davidson_jr, hi! Most treadmills share the same core functionality: speed and incline. That's what I use personally, and that's what the app focuses on.

Speed shortcuts work great on physical treadmills with a large built-in display. On a smartphone screen, they tend to clutter the UI and pull your attention away from what matters. I kept the interface clean and minimal on purpose.

In future versions, we'll add speed and incline shortcuts via swipe gestures, so power users can access them without sacrificing the simplicity of the main screen.

Thanks!

@tom_palmer_ux Yep, context awareness is a big part of Clarafy.

It doesn’t apply the same rewrite everywhere. Clarafy looks at what you’re writing and adapts automatically. A Slack message stays casual and conversational, an email becomes more polished and professional with clear structure, and an AI prompt gets detailed for better results. So in short it know wether your in Gmail, slack, notion, or ChatGPT etc.

The goal isn’t to make everything sound the same, it’s to make your writing clearer while preserving the intent and tone that fit the context.

We also have tone learning called StyleMemory so over time Clarafy can better understand and match your own writing style rather than forcing a generic AI voice.

@evakk Really appreciate that.

That’s actually one of the use cases that inspired Clarafy. Most people don’t struggle with what they want to say, they struggle with turning messy thoughts into clear communication.

The customer feedback example is interesting too. We’ve found that Clarafy can be useful for taking long, unstructured messages and surfacing the core idea more clearly, which saves time when you’re processing lots of information.

Thanks for the support and for taking the time to share your thoughts!

@jared_salois Thanks! Yeah and we have a revert button after each polish that users can easily click👍

@imoluuu Recursi works in tandem with the LLM and almost never breaks things like that it.

It will change things in both files for, instance it will change a function and change where the function is called if that has to change too.

If you're working on a small app the LLM will tend to have all your code to the entire app, but if you're working on a large app -- for instance recursi itself is about 80,000 lines of code -- technically that can all fit into Gemini 3.5 although it's kind of pushing it.

But you also have a lot of tools for choosing which files to include and for it to know what is going on. Sometimes it does result in things not working or a crash but it's really good at sending that information back to the llm so it can figure out which file it needs to go and pull to fix it.

I mean honestly I could go on for a long time about this whole process but that problem is, if not 100% solved, darn close to it. It's extremely rare that it breaks something in that sense, and when it does it's quite easy to fix - its good at pulling not only files but error messages.

I'll go ahead and tell you about a process I use when working on really big projects which is to take the whole project build a prompt that has all the code to the entire thing, and drop that into Gemini. And I tell Gemini to analyze the problem that I'm talking about, tell me the full path to all the files that are involved even if peripherally, as well as just giving some analysis of how it probably can be fixed. But don't write any code.

Then I take what it gives me paste the entire output into a particular tool in recursi and it will build a new prompt that includes all the file paths saw in that output, that is it will grab all the code to all those files, or if I want to set it to only get the signatures or the documentation I can do that. And then I will use that as a start for a new thread where it's more focused and it doesn't have 100,000 lines of code but might have more like 10,000 that is pertinent to the specific problem. And I find that when you do that it tends to be a little smarter because it's not dedicating a lot of it's thought process to stuff that is completely irrelevant.

So there's lots of tricks like that but those really only come into play when you're working on huge apps if you're working on smaller ones no that problem is basically non-existent. If you look at the video where I tell it to take the 3D model and change it to have those amusing explosion effects or whatever, you'll see it affects multiple files and it goes and changes a whole bunch of methods in different files at the same time. So it knows what it's doing if you feed the context to it correctly and this doesn't take a lot of effort on the part of the user most of the tedium of it is handled by the app itself

@zaid_mallik1 I'm not entirely sure what you're asking about the self-improvement loop. This is an app that I have worked on for almost a year, and it's about 80,000 lines of code. When it started out it was just a couple small files that helped manage cutting and pasting between the llm and files so that it would put the changes in the right place. Those also a script to help grab all the files in a directory and put them into a single markdown file so that I could paste it. So like maybe 500 lines of code total.

And when it got to maybe 2000 lines of code, suddenly my productivity started to get much higher because the system was just doing better at all these little tedious things. Maybe by the time it got to 20,000 lines of code, I was way more productive but still here and there there were little issues where I'd have to drop to the file system to fix something. But because my productivity was enhanced that much, fixing these issues with all the faster. So it took way longer to get from 2000 to 20,000 lines of code, then it took to get from 72,000 to 80,000 lines of code. Usually you'd almost expect it to be the other way around because once things get big it starts getting fragile. But again through the process it just keeps improving the thing in every way.

Everything about it gets better the more it increases its functionality and improves itself.

That said when I talk about self-improvement, I'm not talking about what most users are expected to use it for, they're probably not going to be improving recursi itself. Some of them might, I hope for that, but the primary reason they're getting benefit out of self-improvement is that the app is just getting really really sophisticated for something that one person could have put together.

And when I talk about lines of code, obviously I'm not claiming that more lines of code is necessarily better. Recently I went through a process of removing about 20 to 30,000 lines, as it became clear that so much old functionality the llm had just swept under the rug and papered over rather than removing as the app evolved. That is one of the toughest things I've had with llms that it does that. I don't know if the solution to that can be directly built into the app, but it's certainly something that can be taught to users..... You need to regularly go through and tell the llm to get rid of old functionality. And you need to not trust it when it says it's wiped it clean and it's now pristine you need to open it up in a brand new thread and ask it to find the same things and often it will find still a bunch that are left behind. I hope the models get better at this, but if not, it's certainly something that users can learn how to manage so they're apps don't just get filled up with a bunch of crust and then you start seeing old features coming back because the llm sees it in there and thinks it's gospel when it's really obsolete.

@busra_seker1 There's not a huge amount of guidance other than "watch a video showing how simple it is". I do one in the video where I grab the basic 3d app and have it make it so when you click on the sample geometry, it does some amusing explodey effects. It takes only a minute or so and is easy to copy.

I'd like to do a lot more things like that, and add more samples.

@fberrez1 You can see it in the video what's happening.... it uses the web-based chatbots that are free or cheap. It uses copy and paste but it makes it super efficient so you're not having to go in and open individual files and find the right place and select the right text and then control V or whatever. Instead you just click a single button and it has Within the code coming back from the llm information as to which file and what function to replace. There are other things for instance you can add a dependency or delete a function or things like that but for the most basic stuff you just are replacing one function within one class within one file and the system just knows how to do it so you don't have to go and do it yourself you just click a couple buttons.

Look at 11:50 to 12:30 or so in the video where I do it..... it takes half a minute or so only because I am explaining it as I go.

@joy_shekhar It retains it. The first and simplest mode saves it into the "indexed db" in your browser. It is sort of like cookies, except it can store a whole lot of data. You can clear it from your browser history in similar ways to clearing cookies. But it will automatically be there when you come back.. You can tell it to ignore it and come back fresh. (it only changes the functions that change, so not the whole project. good for fairly minor tweaks)

The second thing you can do it open a directory on your disk, and you can "fork" a project into it, renaming it if you want (including changing the names of Javascript classes within). Then it stores it there. Each time you come back to the site, there is a button you can click to re-open your directory and it will just reopen the last subdirectory(s) you were in automatically. So it will be on your disk forever, saving the entire project (but not copying things like shared libraries)

(if you use the first way, you can "upgrade" to the second way, through a menu item. It will copy your projects to disk.)

The third way is to download the repo, which is appropriate if you are changing the whole app itself, or if you want it to store all shared libraries in case the site disappears or something. But it still uses the technology above (the browsers ability to read and write to an approved directory and all subdirectories) to read and save to disk.

@ikapilm Impressed with the concept and execution. The job listings are actually current and the Germany-first approach makes sense given the tech hub there. Would love to see similar expansion to other European countries. Definitely beats scrolling through LinkedIn for English-only roles.

@ikapilm It's great to see you thinking about English-speaking people and helping them by providing resources to find job opportunities in Europe.

@ikapilm Looks genuinely useful, easy to browse English speaking jobs across Europe, and the direct company application links are a nice touch.

@ritik_anand3 Happy to know it helps :))

Would be curious about any feedback that we can get on the product as well

@shaurya_singh21 hey thanks for your feedback, there are internship/fresher filter if you filter from seniority on the platform. let me know if you need any help locating it

@naomie_halioua The regulatory side of global commerce is incredibly complex, so having a structured compliance map instead of manually tracking requirements across dozens of jurisdictions sounds really valuable. How do you handle situations where regulations change frequently or different authorities provide conflicting guidance? Awesome work on this!

@barnaby_lloyd Unified schema, but original source preserved plus an interpretation layer, and ambiguous terms go to human validation rather than being flattened :)

@james_carter35 We normalize at the obligation level, not the document level each regulation is broken into discrete requirements with their own metadata (jurisdiction, authority, product category, effective dates). That's what lets us answer "what applies to this product in this market."

@alexandre_bloch thanks for contributing a lot on this one!!!

@ishashankmi 

"Hey, just upvoted your launch. Would appreciate your support back.

https://www.producthunt.com/posts/deliveryman-ai"

@ishashankmi Love the product.

What stands out is that both Liance and Superplan came from a real founder pain point rather than a trend-chasing idea. You built something useful, hit a wall yourself, and then turned that obstacle into a product opportunity.

Also, both websites are ridiculously beautiful. The attention to detail in the design and product experience makes it obvious that a lot of care went into them.

The compliance space desperately needs products that make security and trust accessible to smaller teams instead of feeling like an enterprise-only game. Liance seems to be tackling a problem many founders don't think about until a big customer asks for it.

Huge kudos to the creators of both Liance and Superplan for solving meaningful problems and shipping them with such a high design bar. 🚀

@punit_bhatt1 <3

@siddhartha_saxena2 Agreed. The planning part gets a lot of attention, but handoff and keeping context intact across people and tasks is often the harder problem. :)