PH热榜 | 2026-06-04

@thamibenjelloun Congratulations on the launch! 🚀

I completely agree that email deliverability has evolved far beyond basic warmup. With inbox providers becoming smarter, sender reputation, engagement signals, infrastructure health, and ongoing monitoring have become just as important as the outreach itself.

It's great to see Mailwarm evolve from a warmup tool into a more comprehensive deliverability platform. Helping 10,000+ businesses improve inbox placement is no small achievement.

Curious to know what's the most common deliverability issue you see today among founders and sales teams that they often overlook?

@thamibenjelloun How are you separating warmup from true deliverability signals especially for teams that already have decent sending volume but still see inbox placement drift?

@thamibenjelloun congrats on the launch team. Other than the usual culprits (dkim/spf/dmarc etc) what are you seeing Mailwarm flag that is otherwise hard to track down?

@bhouy  To be honest, this has been one of our biggest challenges.

When we launched Mailwarm 6 years ago, “email warmup” was barely a known category. But the word warmup makes people think it’s only for the beginning, like a short-term setup step.

After seeing thousands of senders over the years, our view is different: warmup is useful long term to keep positive engagement and protect sender reputation. Or at least, it should be reactivated when reputation drops or before scaling a new campaign.

So I’d say: new domain = warmup is critical. Existing domain = warmup + monitoring is how you avoid silent reputation drops.

Are you asking because you see warmup as a one-time setup, or because you’re thinking about long-term deliverability?

@bhouy This sub-thread is the most interesting part of the launch imo. The product delivers value continuously (reputation protection), but the user only feels it once, at setup. That gap between delivered value and felt value is where most SaaS churn lives. Naming the category "warmup" made adoption easy and retention hard

@ouidad_yassin Thank you. Don't forget to book a call^_^

@ouidad_yassin I feel you new domain deliverability is a massive headache right now, so you are definitely not alone in that struggle.

Thanks for the support on the launch, and here’s to getting your emails straight into the primary inbox! Let us know if you need any help navigating it ;)

@ouidad_yassin Thank you! We are here to help with the struggles!

@skander_karoui Usually 4-6 weeks from a cold start, faster if there's an existing reputation. The defaults come from patterns across +19000 customers. We tested steeper and flatter curves early; both underperformed the current model. Are you warming a fresh IP or one with sending history?

@rania_rimali Great question. Surprisingly, in many cases the issue isn’t authentication or warm-up at all.

The most common problems we uncover are low sender reputation inherited from previous activity, poor list quality, engagement signals that mailbox providers don’t like (low opens, replies, or positive interactions), content patterns that trigger filtering, and inconsistencies between sending behavior and recipient expectations.

We also frequently see domains that are technically configured correctly but have underlying reputation issues that aren’t obvious from standard SPF/DKIM/DMARC checks.

That’s exactly why we built the platform, to help identify the less visible factors that impact inbox placement and provide actionable recommendations beyond the usual setup checklist.

Out of curiosity, what percentage of your emails were landing in spam after you completed the warm-up process?

@rania_rimali Thanks for the support! You are definitely not alone in this this is the hidden nightmare of modern email marketing. Modern spam filters don't just look at your setup anymore; they track ongoing behavior.

When a team tells us their DNS is perfect but deliverability is still bad, Mailwarm usually uncovers IP-level throttling (your email service provider's shared network is compromised), ESP-specific drops (being blocked by Outlook while Gmail is fine), or velocity triggers (sending too fast within short windows).

Deliverability is a moving target, and sometimes a single bad campaign or a dirty IP pool can undo your hard work. We'd love to help you pinpoint exactly where the leak is

@rania_rimali Happy to jump on a call to audit your setup and define the recovery plan!

@fberrez1 Ooh very good question, you are entirely right: ESPs are incredibly smart now, and treating deliverability as just a volume game is a fast way to getting a domain blacklisted.

The upgrade isn't just cosmetic. 2.0 introduces dynamic, non-linear ramp curves. The algorithm constantly randomizes sending intervals, reply footprints, and engagement spacing. It acts like an organic human inbox pattern, preventing ESPs from identifying a mechanical warmup signature.

& For a fresh domain, you're building a foundation. For a damaged domain, you are in triage. The system prioritizes pulling emails out of spam, marking them as safe, and generating realistic thread replies. It's about feeding the ESP signals to work on the trust baseline before any real volume ramp-up is even allowed to start.

Thank you for your support :))

@fberrez1  Exactly. The majority of platforms try to make you think that one-size-fits-all breaks down fast. Gmail's algorithm isn't Outlook's, they weight engagement, authentication, and sending behavior differently. Generic warmup won't catch that.

@bengeekly  @thamibenjelloun  @othman_katim Congratulations on the launch!

@othman_katim  Bonjour 👋, how long does it typically take before someone sees improvement in their inbox placement rates? Congrats, amazing team !!

@richardzhang Thank you for the support !

@richardzhang Thanks, I made a quick check for your domain, happy to share with you some quick wins .

@dmitry_zakharov_ai Thank you, same to to you

@dmitry_zakharov_ai Just reviewed your infrastructure. Few things worth tweaking that could move the needle on placement.

Thank you for your trust @abhishekr_ai. This is the original mailwarm, upgraded. Check it here :

@abhishekr_ai Great to have an existing user in the thread! You are going to notice a massive difference with 2.0. Can't wait for you to try it out. Let us know your thoughts once you dive in :))

@vikramp7470 To help you get the best possible results right from the start, we’ve integrated with our sister tool, Themailx, allowing you to check your DNS records instantly!

To back this up, our deliverability experts also conduct a thorough, manual audit of your domain. We verify your DNS setup, check your domain health against major blocklists, and send you a personalized email with clear steps for any needed optimizations.

A successful warm-up relies on a flawless foundation. While MailWarm does the heavy lifting, it works best when your domain infrastructure is perfectly aligned, and we’re fully committed to guiding you every step of the way to maximize your deliverability.

@vikramp7470 Thank you so much for the kind words about the landing page! The team worked hard to keep it clean.

Regarding the infrastructure checks: It is 100% active, ongoing monitoring.

We know firsthand how easily a downstream teammate can accidentally overwrite a DNS record months after onboarding. Mailwarm doesn't just check your records at the start; it continuously tracks your SPF, DKIM, and DMARC health in the background.

If configuration drift happens, the tool catches the signal drop and flags it on your dashboard early, saving you from a deliverability crisis.

Appreciate you stopping by and asking such a good question :)

@arjayyy Usually 3-4 weeks for noticeable improvement, depending on your starting reputation. You're right that the warmup window is where campaigns stall, most tools rush it. Gradual ramp clears placement faster than aggressive volume.

@arjayyy We get this kind of question every day, and honestly, it’s smart to ask before starting.

It depends a lot on the domain: fresh or aged, past sending history, current reputation, provider, list quality, and how aggressively you start sending while warmup is running.

Some users see strong movement quickly (check this comment with a screenshot : https://www.producthunt.com/products/mailwarm?comment=5426071).

For example, this account went from:

• First test: 75.64% spam

• Previous week: 19.72%

• Current week: 13.61%

Another went from 54.55% spam to 7.29%, then slightly up to 12.14% once campaigns started, which is normal because real sending behavior also affects reputation.

So warmup is not magic. It improves the reputation layer, but your actual sending setup and behavior still matter.

What’s your situation: fresh domain, aged domain, or already sending cold outreach today?

@mavelstech Usually 3-4 weeks for noticeable improvement, depending on your starting reputation. The platform is fully automated, and the setup takes you literally 2 minutes.

@mavelstech I wouldn’t think of warmup as something that “finishes” once and then you forget about it. The timeline depends on your domain age, past sending activity, current reputation, provider, and the volume you want to reach.

For a new domain, I’d start with warmup first, then add campaigns progressively while watching inbox placement and spam signals.

Mailwarm automates the warmup itself, but Mailwarm 2.0 also adds monitoring and access to our deliverability team when you need help adjusting the strategy.

Are you preparing a brand-new domain or already sending from this inbox today?

@natalia_iankovych You're right, small networks kill the warm-up positive effect; we operate +50 000 across the major providers, and they rotate daily.

@natalia_iankovych To be honest, I am happy and proud to write this answer.

And you’re 100% right. If warmup runs on the same small pool of inboxes over and over, it quickly becomes repetitive and loses value.

Mailwarm runs on a network of 50,000+ real and aged inboxes (by the way, mailwarm exist since 2020). The goal is not just to “send warmup emails,” but to create diverse, positive inbox interactions across providers, with enough rotation, email provider mix, and engagement behavior to support sender reputation over time.

That’s also why we built Mailwarm 2.0 beyond basic warmup: monitoring, infrastructure checks, provider visibility, and expert review. We want teams to know if their reputation is actually improving, not just see activity running in the background.

Are you mainly using warmup for cold outreach or for a larger email marketing setup?

@and_bayleaf Andrew, great question.

For us, the “aha moment” is when the customer sees that Mailwarm is not just sending warmup emails in the background. It actually helps them protect reputation and track improvement.

A result like this (screenshot) is exactly why people stay.

When you see that kind of movement, you understand the value immediately.

The real retention signal is when users stop seeing warmup as a one-time setup and start seeing it as reputation protection + monitoring over time.

That’s why Mailwarm 2.0 adds the expert-led layer too: if numbers don’t move, our team helps you understand what to fix.

@and_bayleaf Thanks. Free tiers attract a lot of profiles who never implement anything, and warmup only works when someone's committed to the process. Going paid means we can focus our deliverability team on people genuinely invested in fixing placement, which keeps service quality high for everyone.

On the aha moment: it's the reputation graph ticking up paired with that first batch landing in the inbox instead of spam. Usually shows within the first 20 days. That's when it clicks, they see the trend line moving and the placement data backing it up.

@raphael_goldsztejn Thank you! Would absolutely love to hear your thoughts about it.

@gb1010  Done!

@neelptl2602 Thanks a lot Neel. Starting cold email is exactly the right moment to think about deliverability, before volume increases and reputation problems become harder to fix.

Happy to have @othman_katim or @manal_essalek1 jump on a quick free call with you to review your setup and help you start clean.

Are you starting with a fresh domain or an existing domain with some sending history?

@istiakahmad Thank you so much for the support. Do forward us your feedback once you use it :)

@saad_el_gueddari Wow, thanks so much! Longevity in this space is hard, but it’s operators like you who keep us pushing to build better tools.

It’s incredibly validating to hear you call out the non-linear curves and per-ESP monitoring. The team spent so much time refining the engine to dodge those mechanical warmup signatures you mentioned, because Google and Microsoft have gotten terrifyingly smart at catching basic automation.

Thanks for the launch day support :))

@alina_tyslenok_ 100% and of course beautiful emails are part from the equation.
The biggest hack we have is to get people answer by asking questions.
Any design hacks you have that make people answer from your experience with stripe.email?

@felixlandicho Thanks! 😊

Mailwarm works for both cold outreach and newsletters. We support B2B and B2C use cases, so whether you're sending sales emails, outbound campaigns, or newsletter content, the goal is the same: helping you build and maintain a healthy sender reputation for better inbox placement.

Just to be sure, what's your primary use case right now cold outreach, newsletters, or a mix of both?

@felixlandicho It applies to all the email senders that consider this channel seriously to generate revenue and deliver a great customer experience

@nathan_tran2 Appreciate that. The restart-every-launch pain is exactly why we built it to manage everything in auto pilot. Glad it landed. Thanks for the kind words.

@volodymyr_kreschenko It absolutely is. If email drives your growth, flying blind on deliverability is like running a sales team with the headlights turned off. You think you're moving fast, but you have no real visibility into what is actually making it to your prospects.

With the strict filtering rules major inbox providers have enforced recently, old-school "bot-driven" warmup tools just don't cut it anymore. Mailwarm 2.0 caught a lot of traction because it shifts the focus from vanity activity metrics to live, actionable placement data.

The Real Upgrades in 2.0:

• Live 24/7 Placement Testing: It shows you exactly where your emails are landing (Inbox vs. Spam) across Gmail, Outlook, and Yahoo in real time, rather than giving you a delayed guess.

• Human-Mimicking Network: It taps into a network of 50,000+ real, aged inboxes to simulate genuine human behavior (opening, marking as important, replying with realistic threads) which satisfies modern, AI-driven spam filters.

• Infrastructure Auditing: It constantly monitors your SPF, DKIM, and DMARC health alongside major blacklists so a technical glitch doesn't quietly tank an entire outreach sequence.

When email is your primary growth engine, even a minor dip in sender reputation can quietly trigger a massive revenue leak.

What is the biggest deliverability blind spot or specific friction point you are running into with your campaigns right now?

@shikhilsharma @abhishek_krishnan5 Congrats on the new launch! :)

Whoa! I saw this on the leaderboard and immediately sent it to a security testing agency I have been working with. They asked me to pose this question to you... what specific approach or training data enables these agents to understand context-specific business rules that vary across different applications?

@shikhilsharma Congrats on the launch! How do you handle the edge case where AI agents chain vulnerabilities across business logic boundaries that require context outside the system (e.g., a workflow that's technically valid but violates a specific compliance rule or business policy)? Do you have a feedback loop where human pentester insights on these edge cases automatically update the agents' chaining logic, or is that still manual?

@artstavenka1 Thanks for the support!

Our AI operates with strict boundaries, using a read-only payload mindset to intelligently demonstrate impact and chain logic flaws without triggering destructive mutations or configuration writes in production.

For the Validator layer, we actively simulate exploit paths rather than running irreversible exploit code, allowing us to mathematically verify the risk while keeping your state completely clean.

@igorsorokinua Great question, and you are right that most scanners completely fall short here.

Astra's Autonomous pentesting handles authenticated flows out of the box. You provide login credentials and optionally a login recording for complex flows like MFA or CAPTCHA, and the AI agents log in as multiple user roles to crawl and test everything behind the login wall.

This is actually where AP finds the most critical vulnerabilities, things like IDOR, privilege escalation, and BOLA that only surface in authenticated sessions.

Thank you @kate_ramakaieva 🙌🏻 💙

Thank you @pratyush_r8 - btw, I use Merlin :)

Thank you@danielwayne 🙌🏻

Thank you@sanket_goyal 🙌🏻

Thank you@biswaviraj 🙌🏻

@edward_g you can set a quick Claude pipeline: run APs with CI/CD, MCP to get fix details, and create a PR. With this pipeline, you can have a human in the loop and control over the fixes.

@natalia_iankovych That is precisely the use case: point Astra at the URL, and the agents do the rest, returning a full report with validated findings, steps to reproduce, and contextual fix recommendations your client can actually act on.

@mikhail_prasolov Astra integrates seamlessly with GitHub Actions and GitLab CI, allowing you to automatically trigger automated scans right on every PR merge.

@leventbuilds We never execute fixes directly; we provide the precise code blueprint to your dashboard, keeping the ultimate "merge" button firmly in human hands. Our AI operates strictly as an advisor under tight policy guardrails, allowing your engineers to review, test, and safely apply the contextual fixes themselves.

@nikitaeverywhere Thank you!

No source code needed. You point Astra at a live or sandboxed URL and the agents work from the outside, the way a hacker would.

On minified and obfuscated client code, the agents don't analyse the bundle statically. They interact with the running application, observing API calls, endpoint behaviour, and server responses.

CI/CD integration works via API, trigger a scan against your staging environment before every deploy and get findings before anything reaches production. The only thing source code is used for is the fix delivery layer, where agents read your codebase to generate contextual fixes. The pentest itself needs nothing beyond a URL and user credentials.

Thank you @ronakagarwal3434 🙌🏻

@shanealeven Congrats on the launch team. How do you stop bad user feedback, noisy corrections, or outdated domain assumptions from being absorbed into the tuning loop

@lakshminath_dondeti you can only fine tune oss models. The frontier models are deprecating the ability for you to fine tune them. 😬 Which is one of the reasons we're making this available. But Empromptu is totally model agnostic

@lakshminath_dondeti To add some architecture context, the fine tuned model you build on Alchemy is your asset regardless of what happens upstream with frontier models. When a new frontier model drops, you're not starting over. Your domain knowledge, your corrections, your edge cases are portable. We can use a newer base and retrain on your existing data. The expertise your team captured doesn't deprecate with the model version.

@lakshminath_dondeti Good questions. On the first, the orchestration layer is model-agnostic by design, the point is that you route to whatever's best for the job rather than getting locked to one provider, frontier or open-weights. On the second, that's the more interesting one. Because what you actually own is the labeled data and corrections from your SMEs, not just one frozen checkpoint, a base model leap from 4.x to 5.y isn't a reset. Your accumulated edge-case data is the durable asset, and you re-tune the new base on it. The frontier advancing is a tailwind, not a stranding event. That's a big part of why we frame the data as the thing you own rather than the weights alone.

@1mirul Thanks so much! You picked up on the part we care about most, the ownership piece. So much of the AI stack right now is rented, and we wanted teams to actually keep the thing that gets smarter. Really appreciate you taking the time to look. 🚀

@1mirul thanks so much. If you own your asset you should be able to decide what you do with it whether you compete or whether you decide to sell that asset but you and everyone else should be able to capitalize on the data you own. Your data is getting scrapped and captured anyway. You should at least be compensated

@1mirul The compounding part is what makes it structurally different. Most AI deployments get smarter for the vendor. This one gets smarter for you. That asymmetry is the whole point.

@boyuan_deng1 The user absolutely gets visibility into what runs. You can also do this manually as well for all the tinkerers out there.

@boyuan_deng1 Thanks! Good question. Visibility is something we care about a lot, the whole point is that improvements are yours and shouldn't be a black box, so transparency into what changed is the direction we lean. Want to make sure I give you the exact behavior rather than hand-waving though, so let me grab the precise detail and follow up. What's your use case? Curious what you'd want to see surfaced.

@boyuan_deng1 And the visibility is intentional from an architecture standpoint. A model you can't inspect is one you can't trust in production. You should always know what signal drove a change before it goes into training.

@retain_dev Actually thats kinda the best part if I do say so myself Dr Sean Robinson my cofounder has a PhD is computational astrophysics and he invented a way to get up to 98% accurate outputs out of any model! Its built in to happen completely automatically based on the eval that you write and that last mile is what you label. Thanks for the complement. We know the problem is unless youre a founder, the smes and ai/ml eng are usually separate so you never really get that perfect dataset.

@retain_dev To add the engineering layer to what Shanea described, the quality filtering is what makes the self-improving loop actually work in practice rather than in theory.

The eval you write upfront becomes the ground truth signal. Every production interaction gets scored against it automatically. What surfaces for labeling isn't a random sample of outputs, it's specifically the cases that fell outside your accuracy threshold. You're not reviewing everything, you're reviewing the exact delta between what the model did and what your domain requires.

That's why the labeled dataset stays small and high signal over time. The model improves, the eval catches the new edge cases, and you're always training on the real distribution of your own users rather than synthetic approximations.

The part that resonates with what you described about SMEs and ML eng being separate is exactly the failure mode we designed around. The eval layer is built to be owned by the domain expert, not the ML team. The person who knows what correct looks like is the one defining the signal, not translating it through an eng team.

@retain_dev You hit the exact wall we built around. Synthetic data that doesn't generalize is the thing real usage fixes, but raw interactions are noisy too, so the filtering matters as much as the capture. The short version: not every interaction becomes training data. The signal comes from where an SME actually touches a case, a correction, a confirmation, an edge case getting flagged, rather than from raw traffic. So the human-in-the-loop step doubles as the first quality filter, and the governance layer is where conflicting or low-confidence labels get resolved before anything hits a checkpoint. Curious what your synthetic approach was, since that cold-start pain is real.

@shanea_leven  @priya_kushwaha1 That support nuance problem is exactly the kind of thing this is built for. Your team already knows where the AI gets it wrong on your specific updates, and that knowledge is usually the missing piece. Plugging it into real usage signals so it corrects itself over time is the whole idea. Would love to hear how it goes if you try it.

@priya_kushwaha1 we agree this power is now really accessible for anyone to be able to fine-tune. And yes fine tuning with your own data does absolutely increase accuracy

@shanea_leven  @priya_kushwaha1 And the part that usually surprises people is how small that labeled dataset needs to be when the signal is right. Real production corrections from your own users generalize far better than anything synthetic at 10x the volume.

@shanea_leven  @moh_codokiai yes absolutely you will actually see the performance and accuracy improvements directly in the product. And frontier models have deprecated the ability for you to fine tune their models any more. Also a model trained on your data for your product and your users is always going to be eventually more accurate than a general model.

@shanea_leven  @moh_codokiai 

This is the sharpest question in the thread so far!

You're right that both lift outputs but only one is durable, so we care about isolating it too.

The cleanest way to separate the two is to hold the base model constant and measure the delta your own data adds on top of it, the same base, with and without your SMEs' corrections, evaluated on your edge cases. That delta is the part that's actually yours.

When the foundation model jumps a generation, you get that lift for free like everyone else, but you also carry your accumulated data forward and re-measure the delta on the new base. The foundation improving raises the floor for the whole market. Your data is what raises your ceiling above it.

Quantifying that gap precisely on a given customer's eval set is something I'd rather walk through with real numbers than hand-wave, happy to go deeper if you want. As one example, though (and admittedly anecdotally, based on a single launch customer's internal testing), they saw an improvement of ~30% accuracy from training on the first run.

@shanea_leven  @moh_codokiai First, we're model agnostic -- the user can specify whatever they'd like to use, and we'll adapt the 'baseline' accordingly; the difference is often, for our users, the other efficiencies, such as the training, vertical integrations and other optimization components that, combined, make an enormous difference in both the quality of life they experience while building (setting up actual databases, auth sequencing, et cetera, with real-world best practices), and doing all of the AI-focused functionality from a template-based system that let's me say something like: "I want to build a growth function, and that's going to be me following up with leads we haven't talked to in more than 3 weeks, and I want that sort of outreach to look like this."

I haven't met a business leader yet who wants to replace someone on their team with a system that does that at 98% accuracy. And that's the difference they walk away remembering.

@tanjum Thank you! That's exactly the team we built it for, the ones past the demo stage who actually have to put this in front of customers. Appreciate you taking a look.

@tanjum thank you so much yes. We always try to make everything we do accessible.

@tanjum Two years of production deployments across healthcare, retail, and financial workflows is what shaped the architecture. The edge cases you only hit in production are exactly what we built around.

@busra_seker1 Good question, and it's one of the harder parts. The short answer is we don't treat every correction as automatically true. The governance layer is there partly for this. Conflicting corrections on the same kind of case get surfaced rather than silently averaged into the model, so a human can resolve which pattern is actually right instead of letting noisy feedback train drift in.

The other piece is that expert disagreement is usually signal, not just noise. When two SMEs handle the same situation differently, that often means the policy itself is ambiguous, and catching that early is more valuable than quietly picking one. So we'd rather expose the conflict than bury it. So, the way our system works, you're actually defining what makes your model unique when you help to train it by properly contextualizing these edge cases, and our system has ways to identify good/bad data independently!

Hope you try it out and enjoy it!

@busra_seker1 that's a great question. There is one ground truth so SMEs can override customers but SMEs have to agree what is ground truth

@busra_seker1 Exactly right on the ground truth architecture. On the inconsistency problem specifically, that's where the eval becomes the arbitration layer. Conflicting corrections don't both make it through, the eval scores against a defined expected outcome so noise and contradictions get filtered before they touch training. The model learns from signal that passed a quality bar, not raw feedback volume.

@hellovidya thanks! We all know that data in today's world is gold! We feel that everyone should be able to turn data into gold 😁

@hellovidya Thank you! The name felt right, turning your everyday usage into something valuable that's actually yours. Glad it resonates. 🙌

@hellovidya Thank you!

@german_merlo1 Thank you so much. Excited to get this out to the world.

@german_merlo1 Thank you Germán!

@german_merlo1 Thank you so much! Really appreciate it. 🙏

@ana_popescu2 Good question. In practice it means you're not starting from a blank canvas, you pick the function you want automated and the template drops you onto the orchestration layer that handles routing, context, evaluation, governance, and monitoring underneath, so "building an AI app" is really configuring that for your use case rather than wiring it all yourself. On the framework question, let me give you a precise answer rather than hand-wave the integration story, what are you currently running? Curious whether you're coming from a LangChain/LlamaIndex setup or starting fresh, since that shapes the answer.

In general, we want to abstract away complexity, so for example, you could take a git repo from most other projects (built in Lovable, Claude Code, etc) and be able to transition any component of what you're building (that uses AI/needs what we offer) to help improve accuracy through edge case training automatically over time.

@ana_popescu2 no. We built our own proprietary frameworks specifically designed to get highly accurate AI outputs. So many of our users build their entire products on our platform like we have had users build Soc 2 platforms, AI tax products, full healthcare products for their communities. We have a grant program winner who is building AI workflows for airlines! This is sophisticated tools that ml and ai engineers use made accessible for everyone

@ana_popescu2 To double click on Shanea's point, the proprietary architecture is what makes those wildly different use cases possible on the same platform. The fine tuning loop needs to close reliably whether you're building a healthcare product or an airline workflow, and that's a very different design requirement than general purpose orchestration frameworks are built for.

@joshua_leven Yes we think it's pretty wild too. We think this gap is the missing link for AI to really take off.

@joshua_leven And the cost curve is the part that surprises people most. A smaller model trained on your domain consistently outperforms a general frontier model on your specific tasks at a fraction of the inference cost. You get more accurate and cheaper at the same time!

@joshua_leven That's exactly the pitch! Own the data, get accuracy on your actual edge cases, and stop renting it all forever. Glad it clicks for you. 🙌

@ozandag The correction itself is not the signal, the correction scored against a defined expected outcome is the signal. Without that layer you are just fine tuning on whoever had an opinion that day.

The eval is defined upfront by the SMEs who know what correct looks like. Every correction gets scored against it before it touches training, filtered if it doesn't meet the bar, flagged for review if it's ambiguous. When experts disagree the eval arbitrates. You never train on conflicting signal, only verified ground truth.

@ozandag +1 to what Sean said. We allow the user to first define what good looks like. and we actually remove the hard parts so they can define it in natural language. Often with a single statement. No configs or files so anyone can do it. Then we measure accuracy towards that goal.

@ozandag The pipeline's the easy half. We score corrections before they hit fine-tuning, so a sloppy "this is wrong" doesn't weigh the same as a structured one. Bad corrections are their own failure mode and most teams don't instrument for it. What surfaced this for you?

@mehmet_s_taskesen You're pointing at something we think is the bigger story too. Most companies have years of hard-won judgment living in people's heads and in one-off corrections that never get written down, and when someone leaves, a lot of it walks out the door. Capturing that as your experts work, and turning it into something that compounds instead of evaporates, is honestly the part that excites us most. The app building is the on-ramp. The knowledge becoming a durable asset is the point.

@mehmet_s_taskesen This is exactly the framing that drove the original architecture decision. The problem was never that foundation models were bad. It was that every organization was essentially starting from zero every time because there was no infrastructure to capture what their best people actually knew.

The accountant who knows the exception. The support lead who knows when an escalation is real. That knowledge compounds inside a person over years and then walks out the door. Alchemy is fundamentally an infrastructure problem solved, not an AI feature added. The signal was always there in the corrections, the edge cases, the judgment calls. It just had nowhere to land permanently.

The no code angle is actually secondary to us. What we are really building is the layer that turns institutional knowledge into a durable asset that survives the people who created it.

@mehmet_s_taskesen we totally and completely agree. Better yet. What if you could monetize it as well?

@antonio_manuel1 The key is that not every interaction becomes training data. Raw app traffic is noisy, so the signal comes from where an SME actually touches a case, a correction or a confirmation, rather than from volume. That human-in-the-loop step is the first quality filter. From there the governance layer is where low-confidence or conflicting labels get resolved before anything reaches a training checkpoint, so a noisy or genuinely edge-case interaction gets surfaced rather than silently absorbed. The goal is that bad data gets caught at the gate instead of quietly degrading the model down the line.

@antonio_manuel1 this is really a New paradigm. Subject matter experts can self-correct data to always ensure performance is high for the first time alongside a tool that feels like you're simply vibe coding

@antonio_manuel1 This is exactly the right question to ask and honestly one of the harder engineering problems we solved. Raw production data is noisy by nature so we never let it flow directly into training.

Every interaction gets scored against the eval you defined upfront. That eval is your ground truth and anything that doesn't meet the quality threshold gets filtered before it touches the training pipeline. Edge cases don't get discarded though, they get flagged for SME review because edge cases are often where the most valuable signal lives. The difference is they go through a human in the loop step before they become training data.

The other layer is the SME override architecture Shanea mentioned earlier. When experts disagree on a correction, the eval arbitrates. You're never training on conflicting signal, you're training on verified ground truth.

The result is a labeled dataset that stays small and clean over time rather than growing noisy with volume.

@andrew_paul11 that's the beautiful thing about the app creating the data. The very first time you run the app it creates data!

@andrew_paul11  The short answer is you don't need volume to start, because the signal isn't raw traffic, it's SME corrections on the cases that matter. A handful of expert-labeled edge cases is worth more than thousands of unlabeled interactions, so even a low-volume app can start accruing useful training signal early. It also helps that you're picking a specific function to automate rather than boiling the ocean, so the interactions you do have are concentrated on the cases you actually care about getting right. Volume helps over time, but it's not the gate to getting value on day one.

This is also why we say things like: your 'edge cases actually define what makes your model unique and uniquely valuable' when we talk to prospects because the nuances aren't in the data volume, but the training itself.

@andrew_paul11 The part that makes that work under the hood is that even a small number of high quality runs beats a large volume of synthetic data. Because the signal comes from real interactions against your actual eval, even early data is already shaped around your domain. You're not waiting for volume, you're waiting for signal and those are very different thresholds.

@jordan_hanson1  @xavair 

That's an after-learning number, the gain that shows up once the model has been corrected on a customer's own edge cases, not a starting point. The baseline is the more interesting part of the story honestly, since the whole value is in the delta between where it starts and where it lands once your SMEs have been in the loop. I don't want to quote you a baseline off the cuff since it varies by use case, but I'm happy to walk through a real before/after if you want to see the shape of it.

the pre-training/learning baseline sort of varies depending on a few things, like (a) Did you DIY in your product and are connecting to us after the fact, or (b) did you start building FROM Empromptu initially? The reason this matters is that we have a significant 'impact' on outcomes in both scenarios, but we obviously control more of the 'development lifecycle' in the (b) case, and so the immediate results may be less dramatic (because it starts with the benefit of the vertically integrated optimizations our platform offers).

@jordan_hanson1  @xavair yes! It is. Whats unique about our platform is that we can agenticly get really high accuracy rates as we built a custom model ourselves to make corrections in real time dynamically. But the last percent you can correct responses. So because these tools are integrated into one platform you really get very high accuracy rates

@jordan_hanson1  @xavair Building on what Shanea said, the 98% is what the system converges toward over time, not where it starts. The baseline depends on how far the foundation model is from your specific domain out of the box. The more specialized your use case, the bigger the delta and honestly the more dramatic the improvement curve once your own production data starts feeding the loop.

@new_user___10520260379921a76fc2d64 Great question!! We've actually built in a data anonymizer! to randomize any PII before it goes into model training.

@new_user___10520260379921a76fc2d64 we have several mechanisms to securely protect end-user data, and also offer the ability to mechanically substitute the 'data' from the 'identifying components' through 'john doe' substitutes that makes PII attribution impossible, especially in training applications.

@new_user___10520260379921a76fc2d64 First, our systems are built with HIPAA compliance in mind, which means there are built-in safeguards regulating access to and use of all data that belongs to a customer, but even within that, stricter controls on the unification and association of medical records with personal identifiers, structurally preventing these sorts of issues.

We work with customers in healthcare and would be happy to share specific examples if you or your team would like to meet and discuss how your particular function sets would work?

@daniel_juan2 The protection is that learning isn't continuous in the sense of the model silently shifting on its own, updates happen in controlled cycles your team reviews and promotes, so the model doesn't drift away from intended behavior without someone seeing it.

Each cycle gets evaluated against your edge cases before it's promoted, so you're checking that an update actually improves behavior rather than quietly changing it. And because you own your checkpoints, if a cycle does move in the wrong direction you can roll back.

The goal is the model evolving deliberately on your terms, not drifting out from under you.

@daniel_juan2 The eval is the anchor. No matter how much production data flows through, the model can only update in directions that pass the ground truth your SMEs defined upfront. Usage patterns evolve but correct stays fixed until you deliberately change it.

The versioned checkpoint architecture handles the rest. Every training cycle is inspectable and fully reversible so drift never accumulates silently. Healthcare and financial workflows shaped these requirements from day one, silent drift was never an option.

@daniel_juan2 automatic drift detection for the win! We think about all of these things on a daily basis

@holman Woo, thanks! Love that you're already scheming. The fine-tuning side is honestly the fun part once it clicks. If you end up building something, let me know how it goes, always curious what people reach for first.

@holman amazing! Would be super curious to see what you build!!

@holman let us know how we can support you!

@chen_hao3 The short version is the instrumentation isn't a heavy separate layer you bolt on, the capture happens through the orchestration layer your app is already running on, so the signal comes from the work itself rather than from you standing up a parallel data pipeline.

The point of building on the platform is that instrumentation isn't a second project, it's a property of running there.

On the exact integration surface, I'd rather give you a precise answer than hand-wave it, what's your stack look like? Happy to walk through what getting started actually requires for your setup; feel free to book a meeting with our team!

@chen_hao3 To make that concrete, the instrumentation is intentionally lightweight. You are building on Empromptu's platform so the capture layer is built in, not bolted on. There is no separate SDK to integrate, no custom logging pipeline to stand up, no data pipeline to maintain.

The signals Alchemy needs, corrections, edge cases, application feedback, are byproducts of normal app usage on the platform. The developer experience is just building the app. The training data infrastructure runs underneath it automatically.

That was a deliberate architecture decision. If instrumentation requires meaningful engineering work it becomes a project that competes with shipping. We needed it to be invisible so teams could focus on the application layer and let the learning layer take care of itself.

@chen_hao3 said in another way it feels like you're vibe coding but then you start to notice all of the things devs need are there

@carter_son yes! absolutely. this is how we were able to help one of our Alchemy pilot customers measure and contextualize a 30% improvement in accuracy n their very first training run! It was absolutely incredible and even we didn't expect such a dramatic result.

If you'd like, we're always free for calls to walk people through how Alchemy does this, specific to your workflow or use case.

@carter_son Worth addressing directly because you're pointing at a real gap in how most fine tuning tools are built. Held out test set performance is a proxy metric. What actually matters is whether the model makes better decisions in your specific production environment and those are often very different things.

The eval you define in Alchemy is not a one time benchmark, it runs continuously against live production interactions. So you are always measuring against real user behavior, real edge cases, real domain conditions rather than a static slice of data you curated before deployment. The comparison to the base model is ongoing not a one time checkpoint.

The other piece is that because the eval is domain specific and defined by your SMEs, the performance measurement is actually meaningful to your business. You are not optimizing for a generic accuracy score, you are optimizing for the exact outcomes your team defined as correct.

@carter_son yes you can actually see this live in our dashboard!

@easton_carter Continuous learning is only useful if it doesn't make the model unpredictable, so the answer isn't "learn constantly," it's learning in controlled cycles your team reviews rather than a model quietly shifting under you.

That review gate is what keeps stability and consistency intact, you decide when an update is good enough to promote.

On rollback, yes, that matters for the same reason, if an update doesn't behave the way you expected you need to be able to go back, and since what you own is your data and your checkpoints rather than a single frozen black box, reverting is part of staying in control.

The whole point is the model improving on your terms, not despite you.

@easton_carter From the technical side, continuous learning and stability are actually in tension by design so we had to solve for both explicitly. The eval is what keeps the model from drifting. Every update gets scored against the same ground truth before it ships so the model can only improve in directions your domain actually validates.

On rollback, yes. Every training checkpoint is versioned so if a learning cycle produces something unexpected you can revert to a previous state. You are never locked into a bad update. The combination of eval gating on the way in and versioned checkpoints on the way out is what makes continuous learning safe enough to run in production environments where consistency actually matters.

@easton_carter yes automatic drift detection for the win!

@carlos_leonardo1 The principle is that your training data and the models it produces are yours and governed by the same layer that produces them, isolation and residency are core to that, not an afterthought. But I don't want to hand-wave the specifics on something this important. If you want, I can get you our actual data handling and residency documentation, or connect you with someone on our side who can walk through the architecture properly for your requirements.

Please feel free to book a meeting and we'll walk you through our security protocols!

@carlos_leonardo1 Data isolation is non negotiable for the customer segments we serve. Healthcare organizations and financial workflows were in production on Empromptu before we ever talked to a general market so the architecture was built around those requirements from day one, not retrofitted later.

Every customer's training data is fully isolated. Your corrections, your edge cases, your labeled dataset never touch shared infrastructure and they never inform another customer's model. The model you train is trained exclusively on your data and the weights are yours.

The broader point is that data residency is actually core to the product thesis. The reason Alchemy exists is that your data should build your asset, not someone else's. Letting customer training data bleed across tenants would contradict the entire value proposition.

@carlos_leonardo1 we take privacy and data very seriously

@joshua_cooper2 Building on the ground truth architecture we designed around, every correction gets scored against the eval before it ever touches training. The eval is what decides whether a correction is signal or noise, not volume, not recency, just whether it meets the quality bar your team defined.

On the review question, yes completely. Nothing deploys silently. Teams get full visibility into what corrections are queued, can approve or reject learning cycles manually, and can also trigger retraining on demand for the tinkerers who want that control. The autonomy is configurable depending on how much oversight your team wants in the loop.

@joshua_cooper2 

Thank you! Two good questions.

On the first: not every correction carries equal weight, the ones that matter come from your SMEs touching a case that's genuinely ambiguous or wrong, and the governance layer is where low-confidence or conflicting signals get resolved before anything is treated as training-worthy.

On the second: yes, and that's deliberate. Teams stay in control of the learning cycles rather than having updates happen silently, the whole ownership idea falls apart if the model changes out from under you without review. Human approval before deployment is the model we lean toward, not autopilot. Your training judgment is what makes your alchemy model uniquely valuable, so of course we want to protect that for each of our customers, independently.

@joshua_cooper2 yes absolutely we give teams full autonomy to correct responses. We actually encourage this as it increases accuracy

@annie_liao Congrats on the launch team. You made the point about the pace of models and tools moving very quickly. How do you keep content up to date to deal with that?

@annie_liao Congrats team! Love the gamification of AI learning. We all need it

@annie_liao Congrats!

@talin_roche lets go! so excited to see builders level up on this platform and get certified!

@tom_palmer_ux thank you! the platform is aimed to be beginner friendly and learning is easy to digest so older generations can also benefit!

@annie_liao  @tom_palmer_ux Good question!

@jared_salois thank you appreciate this comment! AI develops daily so we see this as a hub that centralises staying up to date. Community is also a core sticking point we are betting big on

@lakshminath_dondeti its free! :)

@natalia_iankovych 100% - more in store for developers coming soon!

@alina_tyslenok_ thanks Alina! It's a fast moving field! If there are any specific topics you would like to see let us know :)

@kevinzhu 100% - glad to be on the journey with you buddy

@okendoken very interesting

@okendoken Clean idea . Keeping coding , execution , and hosting in the same persistent environment feels like a natural step for AI-driven dev workflows. Curious how you're handling state recovery and versioning inside the VM when multiple iterations of the app are generated.

@okendoken It's really appreciable

Hi @ashishkingdom ! Thanks for your question!

Because Codex cli is open-source, unlike Claude. We love being able to tweak, control, and understand how things work under the hood, and it also gives us a better path to support many different models in the future

@erik_kalmykov 

Congratulations on the launch! 🚀 Appwizzy looks like a great way to simplify app creation. Wishing the team lots of success and excited to see what people build with it!

@sidraarifali Thank you!

@tanjum Thank you!

@1mirul thank you so much!

Hello @natalia_iankovych ,
Thank you for your questions!

We chose Codex because it's open-source, which gives us more flexibility, transparency, and control under the hood. It also makes it easier for us to support multiple models in the future.

As for hosting, our servers are currently located in the USA.

If you can share with us how you usually work with Claude Code it will be very interesting.

Thank you.

@kevin_mckeand1 Thank you Kevin! Excited to see what you and others ship in the next days and weeks. Send us what you built, we’d love to feature it.

@monir_ Exactly. Somewhere along the way, "build software" became "drag blocks until it looks like software".

We’re trying to bring back the obvious requirement: real app, real code, real runtime, real ownership.

@anand_thakkar1 Exactly. For us the VM/workspace is the durable memory: files, Git history, logs, configs, and build output. Codex can resume sessions, but we don’t rely on LLM context as a perfect long-term memory, the agent re-inspects the repo when needed.

Hello @egorka ,
Thank you for trying this and let your review!

As far as I see from our side, your app is working and everything should be ok.

You could contact with me via email: e.kalmykov@flatlogic.com at any time and we will help you with any questions.

Thank you!

@okendoken  @skyninety Yes, recoverable inside the same environment. We treat the VM as a versioned workspace, not just a runtime. The AI works through files and Git/checkpoints, so if it breaks something, we can inspect the diff and roll back from there. External Git is still useful, but rollback should not depend on the user having perfect engineering discipline.

@faisal_2420010 Honestly, same. Once an AI can work where the app actually lives, it's hard to go back.

Not "no rules ever" — just real files, real logs, real builds, and a way to roll back.

@junaidansari @aminmemon Congrats on the launch! I have been an early customer, but then the platform went into maintenance. Is it fully back now? Happy to resubscribe whenever my clients need it next. :)

@junaidansari congrats on the launch Junaid. Can you expand on the "no gsuite"?

Most founders setting up cold email for the first time spend their first week fighting DNS records, SPF misconfigurations, warmup sequences, and blacklist monitoring — before they've sent a single real email. DeliverymanAI's bet that you can hand over that entire infrastructure layer — sub-domain creation, dedicated IP pools, reputation management, reply routing, all automated — and focus entirely on the message and the list, is the right abstraction for a founder trying to move fast. For seed-stage founders doing their first real outbound motion, this is exactly the kind of tool they should find before they spend a week in DNS hell. Added Deliveryman.ai to SoftRankings under the seed-stage sales stack. @junaidansari — what's the most common infrastructure mistake founders make before they find Deliveryman?

@aksayyed Thank you! That's exactly the kind of problem we built Deliveryman AI to solve.

Yes, you can use your existing domains.

In fact, established domains perform better than brand-new ones because they've had more time to build trust and reputation.

Simply connect your domain to Deliveryman AI, and we'll handle mailbox creation, warmup, monitoring, and the rest of the infrastructure for you.

@ria_179 Thank you :)

You can absolutely do it yourself.

You can manage domains, buy mailboxes, configure DNS, spend $$ on warmups, spend $$ on email list verification, and monitoring delivery yourself.

But if your time is better spent closing deals, Deliveryman.ai handles that infrastructure for you.

@aminmemon  @aiswarya_s Thank you for the support! 🙌

Yes, that's correct. Creating & handling the mailbox + warming up domain emails (+ verifying lead list emails + monitoring popular blacklists) is all taken care by Deliveryman AI.

Deliveryman AI handles the infrastructure side of cold email of domains, mailboxes, DNS setup, warmup, email verification, blacklist monitoring, and inbox management. You can bring your leads from Apollo or any other lead source and use your preferred sending workflow.

As for spam prevention, no platform can guarantee that emails will never land in spam. Deliverability depends on several factors including infrastructure quality, list quality, email content, sending behavior, domain age, and recipient engagement. Our motive is to give you the healthiest possible foundation by automating the technical side and following deliverability best practices, but campaign quality still plays a huge role.

Out of curiosity, what's your current outbound stack today?

@dhiraj_patel5 Thank you!

Yes, the warmup is built into Deliveryman AI. Once your domain is connected and your mailboxes are created, the warmup starts automatically.

There's no need to configure warmup or buy a separate warmup tool or manage additional integrations. The entire process of warmup is done for you automatically.

@leventbuilds Thank you. Happy to know that you found our product useful. Great question.

For warmup, we gradually increase sending activity rather than aggressively ramping up volume. We also coordinate warmup behavior with actual campaign activity so mailboxes aren't unnecessarily overworked when they're already sending outreach.

As for mailbox or domain health, that's honestly one of the hardest problems in deliverability. Every email provider behaves differently, and there isn't a single reliable "health score" source. We've integrated with Google Postmaster to gather insights, but the data isn't always comprehensive or updated frequently. In fact, newer versions of Postmaster no longer expose some of the domain reputation signals that were previously available.

Rather than showing a fancy score that may not reflect reality, we're actively working on ways to combine multiple signals and build a more accurate picture of deliverability health. It's an area we're continuing to invest heavily in.

@munis_abbas Thank you, Munis.

At this very moment, you will have to re-route things manually.

But, we will be building a simpler workflow in a couple of months that will make it possible with just a few clicks.

Normally, users don't keep their domains idle. All connected domains keep running campaigns all the time.

Maybe once the development of this new process is live, we can provide you with an option to auto add backup domains if the current domain gets into trouble.

P.S. If you have any feature requests, we have a public todo list as well: https://deliveryman.ai/todo/

@alina_tyslenok_ Couldn't agree more.

The first email is the hardest one because of everything that needs to be setup before sending.
Our goal with Deliveryman AI is to make that setup process feel effortless.
Thank you for the support! ❤️

@iamanantgupta Thank you so much!

Excited to have you on board. If you run into any questions or have ideas for improvement, don't hesitate to reach out.

@skyninety Thanks. Regarding the question...

With Deliveryman AI, domains don't really go "cold" when you're not actively running campaigns.

We continuously balance campaign sending volume and warmup activity. As your campaign volume decreases, warmup volume automatically increases to maintain healthy sending patterns and positive engagement signals. When you resume sending campaigns, warmup volume is adjusted back down accordingly.

This helps ensure your domain maintains a consistent reputation with email providers, even during seasonal gaps or periods of low activity.

We also factor in metrics such as bounce rates, inbox health, and overall sending performance to dynamically adjust warmup behavior over time.

The result is that your domain remains healthy and ready to send, without needing to be treated as a fresh domain after a period of inactivity.

How are you currently handling warmup for domains when campaigns are paused for a few weeks or months?

@natalia_iankovych Thanks! That's exactly the problem we're trying to solve.

Most teams end up stitching together multiple tools just to manage their email infrastructure.

When a domain is detected on a blacklist, Deliveryman.ai automatically pauses email campaigns when necessary (depending on the severity of the blacklist) to help protect your sender reputation.

We also provide step-by-step guides for removing domains from the relevant blacklists. Once the issue is resolved and the domain is delisted, you can safely resume your campaigns.

Our goal is to not only monitor deliverability issues but also help users take the right actions to recover quickly and keep their outreach running smoothly.

Out of curiosity, which 5 tools are you currently using to manage your email infrastructure?

@valeria_khokhlova If you want more info on Novus, you can also check out our landing page (it's pretty snazzy) at Novus.ai or ask a question here!

@ryan_cates1 That's the best kind of product story. The tool caught its own team's mistake before users did.

@busra_seker1 Thanks Büşra, great question!! Novus is absolutely great for catching the issues your users face but don't (yet) report and getting ahead of those.

Novus grounds issues from first party data of every track event with built in statistical filters of what's relevant, what's significant, and how important it is. It also watches the real user sessions (through session replay) to understand what's going wrong in every journey.

The agent even understands your business and application in it's contextual Cortex it generates when you onboard to be able to figure out what problems are critical to your product and what could wait.

All of this data helps Novus to cut through the noise and give you real actionable insights, that you can then investigate and solve with Novus itself (it's pretty awesome).

@zolani_matebese Thanks so much!! Great question, Zolani.

Novus cross-references your GitHub repo, Novus configuration, and live usage data simultaneously, looking for gaps between what's instrumented and what's actually observed.

Every flagged issue gets a severity rating based on data fidelity impact, how central the affected journey is, and whether there's a concrete fix available. And before anything changes, Novus presents an investigation plan for your approval. You see what it found, why it flagged it, and exactly what the proposed fix will do. No PR gets created until you sign off.

@seandotexe Love this! 👏

Amazing to see how fast teams can build with an idea and the right tools, and even better when they can actually understand what users are doing with what they ship.

Excited to see what how community builds and shapes the product space with Novus. Congrats to the team, and thanks for sharing the journey! 🚀

@alina_tyslenok_ We're glad you love Novus, thank you!

That's exactly the problem we're trying to solve. Creating an agent that not only tracks data but also watches it for you and finds those insights... rather than you having to sit in a dashboard all day 😎

@alina_tyslenok_ Thanks so much and what you said is exactly the awesomness of it too! It finds it, fixes it, and you get to review and merge it 🤘

@ashishkingdom great question! Yes it checks every day for anomalies, including funnel drop offs or being rage prompting your AI, and surfaces that as signals. Novus will then run an investigation and post a PR to fix it too!

@thamibenjelloun thank you for your question and congratulations on your launch today!

Low conversion and frustration signals are strongest because conversion is key to a successful business while frustration is a quick early signal you see as soon as the day of release

@priya_kushwaha1 Good point on the accessibility. Currently you can pass parameters such as: https://timetuna.com/pavel?translucent=false&background=false&theme=light to remove background, to remove translucency, etc to increase readibility if we send to a person that we know might have accessibility requirements.

@priya_kushwaha1 good point Priya! We have not implemented many accessibility features yet. We’ll definitely look into this! 👍

Thanks for your feedback!

@ivan_senkin that is so kind of you!

@ivan_senkin Great to hear Ivan!

@denitsapenchevavaltchanova I believe that for different use cases different booking pages could work. If this is a cold outreach and the person does not know you much - having a booking page with a video explaining what you do is a strong case, if you have already agreed to meet, you could share a booking page with a more subtle video background - just to give a warm feel, but not to distract.

@denitsapenchevavaltchanova Definitely valid point, Denitsa!

If you're a real estate agent, you want to get people into the vibe. You could even create a new page per home you're selling.

Something like this would get people into the mood of booking a viewing, no? ;-)

https://timetuna.com/yannick-veys-102025

@and_bayleaf We don't have enough data on that right now.

We expect most people already have a meeting scheduling tool and just move. They move to the $10 plan because of the custom domain and the removal of TimeTuna's watermark on booking pages.

@anand_thakkar1 Hey! Good question. Right now Keen prefers keeping user-agent interaction over tool calls. And in my experience, tool call results have been the single most costly part of the context window.

So if an agent loop grows too much that it cannot fit in the context any more, the simple strategy is to evict oldest tool results for the turn and so on. Since Keen doesn't retain tool results beyond a single turn, the context is already lean when a new turn starts. As a result, this strategy to evict oldest tool results is enough to reduce in-turn context window size.

@zaid_mallik1 Good question. Not exactly mental model, but I have been thinking to experiment with a pre-calculated repository mapping for agents. I don't know if it will surely improve efficiency or performance, but need to actually implement and get a feel for it.

For Keen, yes the focus is indeed context efficiency through compression or lazy loading where possible. I think this is what the biggest win would be.

@natalia_iankovych Hey! This is an open source product and there is no business model associated with it. Yes there is competition which I don't mind at all. If people use it and find it useful, that's good enough for me and worth the effort. :)

@eran_shayshon Hey, yes going off-spec mid-session has not been a problem. I think it's up to you to carefully design how big of a bite you would want the agent to take. As long as it's reasonably planned, it works pretty well.

@tina_chhabra Thanks for your feedback!

@grace_lee26 Turn memory is pretty simple and dumb. Right now it's a Go struct with two fields: files_changed and failed_bash_commands. This is to give later turns a simple sticky note: this is what changed in the previous turns and this is what failed. That's it.

The reasoning behind this is that if agent needs to refer to some tool result before, it should simply run that tool again. In fact, SoTA agents do that frequently: they read some file, does some change. Later, if you ask them to do something else, they read the same file again to ensure the latest state.

So Keen's thought process is: just don't retain tool call results from read_file or grep or other tools after an agent turn loop finishes.

@retain_dev I am not entirely sure I understood your question :D

Right now, there is nothing done specifically for prioritisation between multiple files in Keen.

@ianhxu In my experience, it has been significant. I have done some very basic benchmarking between Keen vs OpenCode. In those benchmarks, I have clearly seen Keen's context window drops 1/10th from one agent turn loop to the next.

Context window size for OpenCode grows linearly. The more a multi-turn conversation progresses, it keeps going up. With Keen, it grows within a turn, but comes back down significantly after a turn. The next turn starts with a far smaller context compared to previous turn's end.

The tradeoff that Keen has here is pretty obvious: if agent needs to refer to some tool call results done a turn or more ago, that result is no more available. The counter-argument here is that models can always re-run those tools, assuming those tools are idempotent. There has to be some shenanigans done for MCP tools, which I intend to address in next releases.

Here is a Claud-written analysis: https://mochow13.github.io/keen-code/docs/turn-memory-analysis.html. It's a bit dramatic but good for understanding the idea.

@rohanrecommends when orchestrating multi-step workflows across local files, native apps, and cloud services, how does personal computer decide which fronteir model to route each subtask to?

@tina_chhabra Yes! Making it so Koji can point to and draw on problems directly is core to what makes the tutor so effective. Koji can add points to a graph or ask questions about different parts of a problem, like "Which of these operations is the next step?" Our goal is to help the learner get "unstuck" just enough so they can solve the problem on their own. Koji also will try a different tack if the learner isn't getting it one way. This is one advantage of an AI tutor over a human – infinite patience! :)

@nbushak Looks great! Can the agents spin up playwright for tests?

@raveesh Thanks so much for being an early user and believer in us!

@seandotexe Thanks Sean! Yes, it feels freeing not having agents running wild on my personal laptop, with our VMs only having access to development credentials.

@fberrez1 Yes, it does! You get full control over a linux box in the cloud for each claude code and codex thread (and a template box that gets snapshotted and cloned to produce the VM for every thread). It's great at running chromium headless, running playwright, and even sending you screenshots to the thread (visible in the desktop app and mobile). And because each thread/VM is independent of the others you can have a bunch of them running multiple copies of your app and chromium in parallel without slowing down the others. If it works on your laptop via the codex/claude CLI, it will almost certainly work on boxes.dev.

@iloveluce Thanks Luciano!

@samyak_sanklecha We handle this with the notion of a "main box" or template box, which you can imagine to be your development laptop in the cloud. When you set up boxes.dev, our coding agents find your environment variables and undeclared dependencies locally, and then get your app fully running in a cloud VM. After it's set up, you can always jump into the terminal or make any changes you want on the template box.

When you create a new task, that main box is snapshotted (filesystem and RAM), and then a new independent fork is created from the snapshot.

So whenever you want to add context or update your setup on boxes.dev, change it on the main box and update the snapshot, and all future threads will get created from that snapshot.

@gil_feig Thanks a ton Gil!

@ianhxu Yes! This was the primary motivation for us -- you can have multiple threads/agents running in parallel, each with their own totally independent machine. No more running out of resources locally or having to juggle git worktrees. Since we have a template/main box that you have full control of, there's also no setup required per-thread/per-machine, each thread's VM starts from a perfect snapshot of the template box.

@sergebulaev Over the long term, we'll support spinning up VMs in local point of presence datacenters, so any threads/agents you create or wake up while traveling can be colocated with you.

But one thing I've noticed using boxes.dev on a plane is that since I'm just sending messages to a thread and looking at screenshots from the agent testing its own work, the user experience isn't that bad even with a lot of latency. Of course, if I have to use the terminal, that's slower, but on a plane I end up just pushing the agent to do whatever I wanted to do manually in a terminal window.

@arjun_reghu Yes, absolutely. This will help with in-meeting intelligence (like meeting assistant) and is faster than the fireflies version. It can respond in voice in a very short time. For comparison, for a smaller answer, fireflies will start speaking after the sun agent has completed the answer, or is halfway. Take a look into our playground where you can try it out.

@jaison1993 Sun takes in text input (both partial and final transcripts - streaming). It gives out both text and audio output.

@ashishkingdom Yes, you can actually give trigger words or names to the agent. The agent will then respond only when called with the name (and is asked a question), not when passively mentioned in a conversation. It also looks at voice activity to see if someone is actively speaking to avoid interrupting them.

@regaldreamtech Exactly — that's the core use case Sun was built for.

Fireflies and Otter listen silently. With Sun, you can build an agent that listens, knows who's saying what, and actually speaks up at the right moment — to summarize, answer a question, surface a related decision from earlier in the meeting, or even moderate.

@aisha_m_a Yes, the trigger words list is for alternate names of the agent. Agent will see it as a wake up call to answer. It is also helpful if the transcription service used sometimes misses to transcribe properly. For instance, John can be sometimes written as Jon and this could help in those scenarios as well.

@aswanth_viswanathan8 Yes, it is possible to add context mid-session using context.update. It could be useful if you want the agent to have certain information, like sales number or a context about the ongoing discussion, in the middle of discussion.

@real_digidavid The model doesn't detect speakers, but it takes in speaker name and what they said as a streaming text input. It can therefore support infinite speakers theoretically. We have tested up to 25 participant meetings. The output from the model is both text and audio. The output audio has 4 different voices which you can switch while the session is in progress as well. 2 male and 2 female voices.

@ilya_makarov2 Good question. You can set a hotkey to point to a person or group of people and that will deliver to their email as a transcript + link to voice. If they themselves are Carbon Voice users, it will deliver right into their conversastions.

Or you can have a hotkey pointing to an agent or any webhook. There isn't a direct feed to a Telegram user yet, but could hit a n8n or Zapier workflow that would direct it to that user on Telegram or any other platform.

@maxmusing Congrats on the launch. Just a short question: when the AI uses your sematic layer definitions, how does it handle edge cases where the same metric might need slight variations across different contexts, say currency conversions, time zones or business units?

Thanks @thamibenjelloun!

@ada_johnsen great question. Each team can (optionally) have their own set of metrics, and you can even define a metric using another team’s metric as a base. We support team-level AI context to teach the AI exactly how your team works.

@samyak_sanklecha we’ve found that most great companies have centralized teams responsible for defining these kinds of metrics for the other teams.

@kris_lachance context is all you need

Thanks @seandotexe! Yes, I was thinking about creating an MCP or a CLI you can use in any of those AI tools, which would make it even easier to use

@samu_monteiro I tried it, I liked it, congratulations on the launch

@munis_abbas thank you! Hope you enjoy using it

Thanks @alina_tyslenok_!

@perizatka_03 Claude Code is an excellent tool. But it's a session. When it's done, it's done.

Extella persists.
Every solution becomes a permanent Expert — a verified, reusable module callable from anywhere: chat, API, another expert, a robot. Claude Code writes code for you. Extella builds a growing library of capabilities that outlive every conversation.

Extella runs on anything.
Claude Code runs in your terminal. Extella runs on any device you connect — your laptop, a server, a Raspberry Pi, a robot. Through Targets, the same expert executes wherever the task requires.

Extella has memory that evolves.
Concepts accumulate knowledge permanently. Rules shape behavior. Through Sleep — fine-tuning — everything the system learns gets embedded into the model's weights. The next session starts smarter than the last one.

Extella is multi-agent with infinite context.
Claude Code is one model, one context window. Extella decomposes complex tasks across specialized agents recursively — each with a clean context, its own LLM, its own memory and rules. No context overflow. No ceiling.

Now the part no other platform comes close to: CSPL.

When Anthropic ships a new feature to Claude Code, an engineer wrote it, reviewed it, deployed it. You waited for it. You had no say in what got built.

In Extella, if the execution layer doesn't do what you need — you define a new one. Not a plugin. Not a config. A new CSPL container that teaches Extella how to interpret an entirely new class of experts.

Want experts that execute as Rust? Define a CSPL. Want a domain-specific language that describes a financial strategy, a molecular structure, a neural architecture, a CNC toolpath — and have Extella execute it natively? Build that CSPL. Now every expert written in that language runs correctly by construction. The language itself prevents incorrect code.

And this is where the 10x–1000x efficiency comes from.

A general-purpose language like Python carries the full weight of everything it can do. For any specific domain, most of that is irrelevant noise — and noise means tokens, means ambiguity, means errors, means LLM cycles spent on syntax instead of meaning.

A DSL built for one domain eliminates that noise entirely. If your CSPL describes a financial strategy, there is no syntax for doing anything other than a financial strategy. The model works only with meaning. No boilerplate. No misinterpretation. No retries.

The more constrained the language, the less the model needs to do — and the more reliably it does it. That's where the multiplier comes from. A 10-line DSL description replaces 300 lines of Python. A domain-specific instruction replaces five rounds of prompt iteration. At scale — across thousands of experts, dozens of agents, running continuously — that difference compounds into orders of magnitude.

At the extreme end, CSPL reaches hardware. Verilog through Extella doesn't just generate code — it synthesizes directly to FPGA and dynamically builds processor architecture per task. That's Patent US 12,099,462. The architecture adapts to the algorithm, not the other way around. The limit stops being software. It becomes physics: speed of light, transistor density.

This is the distinction that matters:

Anthropic updates the product for the user — a team decides what gets built, you receive it, you adapt to it.

Extella is updated by the user from a single request. You describe what you need. Extella builds the Expert, the CSPL, the Rules. The capability becomes permanent. The system is more capable than it was this morning — not because a company shipped a release, but because you had a conversation.

Extella is the first genuinely self-evolving AI — not in the marketing sense, but in the literal engineering sense. The system's own components — memory, reasoning, execution, hardware interaction — are all implemented as Experts. Which means they all inherit the same three planes of evolution: the code grows more complex, the description evolves, the execution layer gets replaced with something better.

The system improves its own way of improving.

Every other AI platform has a ceiling defined by its developers. Extella's ceiling is defined by what is physically computable.

They are tools. Extella is the first system that builds its own tools — and then builds better tools for building tools.

@ella_bye Thank you! Finding lost files is one of those quiet wins that actually saves your day.

You can already use Extella from your phone via the web version and run Experts as long as one of your desktop devices is online. So it's usable today — you just need a machine running in the background.

A full mobile app is on the roadmap — where your phone will also act as a target device. 🙂

@novamaker01 Both. And you control which.

You set the policy. Extella enforces it.

Every Expert runs on a Target — a specific device you've registered. You can pin any Expert to a local Target explicitly. That Expert will never leave your infrastructure, regardless of what the RL Router would otherwise prefer. Local-only is not a global toggle — it's a per-Expert, per-Agent, or per-Rule decision. As granular as you need.

At the Agent level, each agent has its own LLM configuration. You can point an agent at a local model — Llama via Ollama, Mistral, whatever you're running — and that agent will never make an outbound model call. Other agents in the same profile can use cloud models. They coexist in the same pipeline.

Rules and Concepts orchestrate the whole thing.

Rules are the highest-priority layer. The Router optimizes within the envelope you set, not outside it. But orchestration goes deeper than routing. Rules define when to switch models, when to escalate from a reflex to a reasoning chain, when to delegate to a different agent. Concepts carry the accumulated knowledge of what worked before — which model performed better on which task type, which pipeline failed and how it was fixed. That knowledge feeds back into every future decision. The system isn't just following your rules. It's learning from its own execution history and getting more precise about when to apply which resource.

CSPL enables auto model switching at the execution layer.

You can define a CSPL that dynamically selects its execution backend based on the task at runtime — local inference for latency-sensitive work, cloud for complex reasoning, FPGA synthesis for compute-bound algorithms. The switching logic lives in the container, not in a config file. Which means it can itself be evolved, versioned, and replaced without touching anything else in the system.

So in practice:

- Sensitive data pipeline → local Target + local LLM agent + Rule enforcing local-only → nothing leaves
- General reasoning tasks → RL Router picks the best available model, cloud or local, based on cost and accuracy
- Hardware-adjacent tasks → pinned to the device that has the FPGA or the sensors

The architecture was built for exactly this split — because in enterprise and robotics contexts, data locality isn't optional. You don't have to trust the system to make the right call on sensitive workloads. You just write the Rule, and the decision stops being a decision.

But step back for a second — because the routing question is actually the smaller story.

Claude Code is a session. When it's done, it's done. Extella persists. Every solution becomes a permanent Expert — verified, reusable, callable from chat, API, another expert, or a robot. Claude Code writes code for you. Extella builds a growing library of capabilities that outlive every conversation.

Extella also runs on anything. The same expert executes on your laptop, a server, a Raspberry Pi, or a robot — wherever the task requires. Memory accumulates permanently through Concepts. Through Sleep — fine-tuning — everything the system learns gets embedded into the model's weights. The next session starts smarter than the last.

And through multi-agent profiles, complex tasks decompose across specialized agents recursively — each with a clean context, its own LLM, its own memory and rules. No context overflow. No ceiling.

Now the part no other platform comes close to: CSPL and the 10x–1000x multiplier.

A general-purpose language carries the full weight of everything it can do. For any specific domain, most of that is irrelevant noise — tokens, ambiguity, errors, LLM cycles spent on syntax instead of meaning.

A DSL built for one domain eliminates that noise entirely. If your CSPL describes a financial strategy, there is no syntax for doing anything other than a financial strategy. The model works only with meaning. No boilerplate. No misinterpretation. No retries. A 10-line DSL description replaces 300 lines of Python. A domain-specific instruction replaces five rounds of prompt iteration.

At scale — across thousands of experts, dozens of agents, running continuously — that difference compounds into orders of magnitude: 10x, 100x, 1000x and beyond depending on domain complexity.

At the extreme end, CSPL reaches hardware. Verilog through Extella doesn't just generate code — it synthesizes directly to FPGA and dynamically builds processor architecture per task. That's Patent US 12,099,462. The architecture adapts to the algorithm, not the other way around. The limit stops being software. It becomes physics: speed of light, transistor density.

And everything above is the baseline. Zero-state behavior.

The system is adaptive by design and evolves along three axes simultaneously:

From errors and new knowledge. Every failed execution, every corrected output, every new Concept added feeds back into the system. The Expert that failed gets updated. The Rule that caused the wrong routing gets refined. The Concept that lacked context gets enriched. The system doesn't repeat mistakes it has already resolved.

From users. Every request that pushes the system past its current capabilities results in a new Expert, a new CSPL, a new Rule — permanently. One user's solution becomes infrastructure for every subsequent similar task. You don't file a feature request and wait for a release. You describe what you need, and the system builds it.

From researchers. When a new paper drops — a better fine-tuning method, a new routing algorithm, a more efficient inference architecture — you don't wait for Anthropic to ship it. You implement it as an Expert or a new CSPL container. The Sleep expert gets replaced with the new method. The RL Router gets updated with the new algorithm. Research becomes capability in hours, not quarters.

This is the distinction that matters:

Anthropic updates the product for the user — a team decides what gets built, you receive it, you adapt to it.

Extella is updated by the user from a single request. The system is more capable than it was this morning — not because a company shipped a release, but because you had a conversation.

Extella is the first genuinely self-evolving AI — not in the marketing sense, but in the literal engineering sense. Every component of the system — memory, reasoning, execution, routing, hardware interaction — is implemented as an Expert. Which means every component inherits the same three planes of evolution: the code grows more complex, the description evolves, the execution layer gets replaced with something better.

The system improves its own way of improving.

Every other AI platform has a ceiling defined by its developers. Extella's ceiling is defined by what is physically computable.

They are tools. Extella is the first system that builds its own tools — and then builds better tools for building tools.

@novamaker01 

Felix, good question — and it goes straight to the architecture.

By default, every Expert runs locally on the device where Extella Desktop is installed. There's no automatic "local vs. cloud" routing happening under the hood — the platform doesn't make that call for you.

If you want a hard local-only guarantee for certain Experts, you simply don't assign a target when running them. A target is the mechanism for routing execution to a different device (e.g., a remote server or second machine). No target = always local, full stop.

As for AI model choice (local LLM like Ollama vs. a cloud API) - Extella doesn't dynamically pick a model per task. You implement that routing yourself (e.g. when setting an agent in Agent Builder of the Pro Plan), which actually gives you more control, not less.

So to directly answer: yes, local-only policy per Expert is trivially enforced — it's the default. The platform gives you the routing primitives; the decision logic is yours.

@azizb This is exactly what Extella is built for — not just automating one task, but becoming the operational brain of an entire business. Thanks for sharing!

@henry_habib Good question — and an honest one.

Conflicts surface explicitly, not silently. When two Rules contradict, the agent flags it during interaction. You decide which stays, or you merge them into a new Rule that resolves the tension. Nothing conflicting quietly accumulates in the background.

For knowledge across workflows, Concepts handle it the same way. When similar knowledge comes in from different sources, the system deduplicates and merges rather than stacking duplicates. If there's a genuine inconsistency — two workflows that learned opposite things — it gets surfaced for human resolution, not auto-resolved by the system.

But here's where it gets more interesting.

You can teach the agent exactly how to handle ambiguity — not just flag it, but resolve it. You define Rules for how to research a contested claim, how to fact-check, how to assess recency and relevance, how to weigh conflicting sources by importance. The agent learns your epistemology, not just your preferences. Once those Rules exist, the same judgment you'd apply manually gets applied automatically — every time, at scale.

You can also teach the agent to recognize the boundaries of its own knowledge. Rules and Concepts can encode a self-assessment protocol: when the agent hits a gap, it doesn't guess — it identifies what it doesn't know, flags it, and can trigger an automated research or learning workflow to close that gap. It learns to know what it doesn't know.

And then the final step: you automate the configuration work itself. Once the agent understands your standards for conflict resolution, fact-checking, and self-improvement — you build Experts that handle that process automatically. New knowledge comes in, gets verified against your criteria, gets merged or flagged, gets added to memory — without you touching it.

The goal of human involvement is not to be always present. It's to teach the system well enough once that it stops needing you for that class of decisions entirely. Every hour you spend teaching the agent reduces the next thousand hours of manual intervention to zero.

That's the trajectory the architecture is designed for. You start in the loop. You work yourself out of it.

Thank you for asking!

@zaczuo Since it ships as a separate app, how do you handle window state/persistence across sessions and is there a path to merge the pain into the main terminal center, or is the separation intentional for safety and compliance?

@liz_stephany1 Chloe 🤝 Close's real sales team. Always our own best power users!

@dhiraj_patel5 The great thing about a native voice AI agent in a CRM like ours is that there are no silos between everyones customer communication :) But if that ever happens, it would be the exact same scenario as a sales rep calling a prospect that is already chatting with another account executive. The prospect would tell this to Chloe, and she would acknowledge it and make a note in the CRM and wish the prospect a lovely day :)