PH热榜 | 2026-05-11

@jason_shen3 Honestly the matching part makes sense to me because searching LinkedIn with keywords feels useless half the time.

I’m more curious about the outreach stuff though, since most AI-written cold emails are painfully obvious after the first line. Wondering how natural these actually sound when people reply back.

@jason_shen3  @hotwheels_bo  @chrismessina The strongest signal here is still intent → relevance → explanation that why connect layer is what makes it feel less like scraping and more like real matchmaking. If that reasoning stays accurate at scale, this could genuienly rehape cold outreach quality ✨

@jissin lu 😄 If Confucius had Articuler, "in any group of three, one of them is my teacher" would've become "in any group of 980 million, the right teacher is one query away." （I really like your porofile pic haha :)

Jokes aside — mentorship is one of our favorite use cases, and not just for founders. College students and young professionals use us heavily — the question "who walked the path I'm trying to walk" is the deepest networking need most young people have.

Try a Directory Match like "USC grads who broke into big tech in the last 3 years" — that scopes the search to your alumni network specifically and surfaces people who remember exactly what your stage feels like. Way more useful than a generic LinkedIn search for "Google PM."

Founders find investors. Students find mentors. Different intent, same engine. What domain are you in?

@jissin Hi Lu, happy to share a little personal story! I've seen it firsthand.

I just graduated last year, and when my friends were job searching, they had the drive but not the network. I let them try Articuler.ai, and the most valuable matches weren't recruiters — they were mentors. Alumni and professionals who actually took the time to review resumes, reframe their story, and show them how to reach out.

As a recent grad, I can tell you: the biggest gap early in your career isn't skills. It's access. You don't have 20 years of warm intros to fall back on. Articuler.ai closes that gap — not by handing you a list of strangers, but by finding people who are willing to help and telling you how to start that conversation.

@itsluo Luo, this is exactly who we built Articuler for 🙏 Solo founders feel this bottleneck the hardest — every hire, every investor, every first 10 customers is a single-person decision with no team to crowdsource intros from.

Try a query like "early-stage operator who's done 0-to-1 GTM at a solo or 2-person team, open to fractional or advisory roles" — that's the kind of search LinkedIn can't run. And Playbook will tell you things like "this person turned down 3 fractional offers last quarter because the founders pitched salary instead of equity" — the intel you'd never find on a profile.

What's the most painful "right person" search on your list right now? Happy to run it.

@itsluo Thank you for liking our product! Perhaps you can take a look at our directory feature, it helps you with finding very specific people for your need. If there isn't one that suits you, you can always reach out for us to give us ideas!

@venier Giacomo, thanks 🙏 Yes — recruiting is one of our strongest use cases, with one specific philosophy: good hiring isn't finding a list, it's finding people whose background aligns with what you're building.

"Growth engineer" returns 50,000 LinkedIn results. For Snaply, you'd want something like "growth engineers who've shipped voice/audio products or written about real-time AI infra." LinkedIn can't filter for that. Public footprints (tweets, blogs, GitHub) can. Happy to run it for you.

Also worth flagging: a real chunk of Articuler's users are young professionals actively looking to join startups exactly like Snaply — they're already on our platform describing what they want. We've been thinking about building a dedicated startup-hiring directory that matches founders like you with these candidates. Snaply feels like the right launch partner for this — are you in?

@venier Thank you for your comment, Giacomo. Yes, just as Jason mentioned, we do exactly what you asked!

We find you the right person for your next hire, but we can also do matching on the other side and connect potential employees to you by adding founders and job seekers into the same directory.

@davitausberlin Davit, we're not a database — and respectfully, not trying to be a better one.

The "database + search + cold email" stack — ZoomInfo, Apollo, Lemlist — is structurally spam infrastructure. Buy a list, run keyword filters, blast templates. The whole industry's TAM depends on filling professional inboxes with messages people don't want to read.

Articuler is on the opposite side. We're a content distribution network for professional intent.

Keyword search matches strings: "VP of Marketing" returns every VP of Marketing. Intent matching understands meaning — we read 980M public footprints (posts, podcasts, hiring patterns, check histories, etc.,) and surface the specific humans whose current intent overlaps with yours. Where there's actual exchangeable value on the table.

A database tells you who exists. We tell you who's worth meeting, and why.

Worth noting — FlowMarket and Articuler are pointed at the same horizon from different starting points. You're letting AI agents discover and negotiate B2B deals; we're building the layer where humans find the right humans to begin with. Different problems, shared belief: the future is about fit and intent, not lists and blasts. Would love to chat someday about how the layers might compose 🚀

@erictian Yes, you can! In-event matching is on the last stage of beta testing, please dm me, and I can provide you more details.

@erictian Of course! Our event matchmaking function will be launched no later than late June. Happy to reach out and discuss further details with you.

@ann_y1 Yes, just as simple as that! Then you will get a list of profiles with a detailed summary about why they fit your profile and your goal!

@ann_y1 just tell us your target's image, and we deliver!

@charlenechen_123 Thank you Charlene! We only want to deliver connections that are useful

@le_ng_c_dan_nhi ❤️

@hans_c Hans, this is one of the most thoughtful reads of the product I've seen 🙏 You caught the "filtered through yours" detail that we obsess over most — most cold email tools research the recipient but treat the sender as anonymous. The message ends up technically accurate and emotionally hollow.

To your three questions:

1. Softer vs transactional — We don't think they're that different. Sustainable connections are built on exchangeable value — what changes is just the form. · Sales: a specific insight matching what their company's working on (recent hires, launches, public asks). · Fundraising: your domain insight intersecting their current thesis (recent posts, podcasts, check history). · Mentorship: genuine curiosity from someone walking their path — sometimes a shared alma mater is enough.

Generated Email and Playbook adjusts the form, so a sales pitch doesn't read like a mentor request, and vice versa.

2. The 8x figure — Overall rate, not cherry-picked. Caveat: consumer/SMB sees higher reply rates than enterprise — senior recipients are harder regardless of personalization quality.

3. Bring your own context — Current version infers from your public footprint + auto-learns from your preference signals (saves, outreaches, conversions). Next version lets you bring explicit context (notes, what you're working on, who you've talked to). Exactly how you framed it.

Also — Me.bot is the adjacent problem we care about deeply. The day everyone has a real personal memory layer, Articuler's "filtered through yours" gets exponentially better. Rooting for you 👌

@hans_c Thank you Hans, really appreciate the thoughtful breakdown — and you nailed exactly why Jason and Bob built Articuler.ai this way. Starting from intent rather than a name or title is how people actually think about networking. You don't wake up thinking "I need to find John Smith." You think, "I need someone who can help me with X." Every tool on the market forces you to translate that backward into keywords. We wanted to skip that step entirely.

And yes — the "filtered through yours" piece is what we're most proud of. The Playbook doesn't just research the other person. It reads both sides and finds the threads between you. That's why the outreach doesn't sound generic — it's grounded in what you actually have in common, not just what they've done.

@hans_c That’s exactly what caught my attention too most networking tools still feel very search-first instead of goal-first.

The part about outreach being filtered through both profiles feels especially interesting because generic personalization is becoming easier to spot now. Curious to see how well it handles more relationship-driven networking compared to transactional outreach.

@jojo_li JoJo, great question 🙏 Short answer: both — but finding and pitching clients is actually where Articuler shines hardest.

Two sides of the same engine:

· Finding — instead of "VP of Marketing at SaaS companies," you can run "VPs of Marketing at mid-market SaaS companies who recently mentioned localization pain or hired international growth roles." That's signal, not title — and signal is what tells you who's actually ready to buy.

· Pitching — this is where Playbook earns its keep. For every prospect, we read their entire public footprint and tell you what they care about, what they've publicly criticized, what kind of pitches they've responded well to. Think of it as the briefing you'd get from a friend who actually knows them — the friend most BD reps wish they had before every cold call.

Then we draft the first email anchored in shared context, not a template. 15% reply rate, 8x cold outreach.

What does your ICP look like? Happy to run a sample search — would love to see Articuler land a Vozo deal 👌

@cruise_chen We're deliberately not a batch tool. Articuler drafts a separate message per person based on that specific person's profile, recent activity, and your overlap with them — sending the same message to a list isn't really the workflow. Today you can use the drafts in email, LinkedIn DMs, or anywhere else you paste text. The tradeoff is real: you send fewer messages, but reply rate is the multiplier (we see ~8x over generic blast). If your headache is prep time per email rather than send mechanics, you're in the right place. If it's pure volume, we're probably not the right fit.

@cruise_chen Right now, articular.ai can connect directly to your Gmail. However, we can also craft dedicated messages for you to copy and paste on other social media platforms for outreach (for example: LinkedIn, Twitter, etc.).

@yankun_zhao 🚀🚀You next financing round is on us!🚀🚀

@yankun_zhao Hey Yankun, you get the gist!

@haoran_fok Henry, yes — strongly yes 🙏 BD is one of our top use cases, because every partnership is ultimately people-to-people. The deal closes between two humans.

Real examples from our users:

· Consumer electronics brand → finding EU distributors who've ranged competing audio products

· CRM SaaS → mapping VPs of RevOps at companies that just switched off Salesforce

· Forklift manufacturer → finding warehouse automation integrators with Tier-1 deployments

None findable on LinkedIn keyword search. Partnership BD lives in the signal layer, not the title layer. What angle are you working on?

(BizCard looks slick 👌)

@novamaker01 Glad that landed. In-Event Match is the part we think gets least talked about and matters most — it's the only place where the cost of meeting the wrong person gets paid in real-world hours, not just an unread email. If you've got a conference coming up, worth signing up an event slot.

@novamaker01 Thank you Felix! Event matchmaking comming next, feel free to connect and I will get you our first hand information!

@dzaitzow Thanks Daniel!

@erfanveisi Thank you for you comment Erfan! Great question, and I believe this is the reason we are different than most professional networking tools:

The Playbook doesn't rely on a single source. We aggregate across the public professional web — LinkedIn, company pages, GitHub, Twitter/X, published articles, podcast appearances, conference talks, Substack, patent filings, academic papers, and public investor/portfolio data. Basically, if it's public and professionally relevant, we're indexing it.

But the real differentiator isn't breadth of sources — it's how we process them. Every piece of public content gets vectorized into the same semantic space. So when we build a Playbook, we're not just stitching together bullet points from different platforms. We're computing the actual relationship between what that person has said, built, invested in, and written about — and mapping that against your background and intent.

Hope this answers your question, and feel free to check out our product! Don't forget to apply our promo code 🎁PH26Q2 for one month free access!

@thekrew Really appreciate this — and you're touching on exactly the right problem.

Volume was never the bottleneck. Relevance is.

The 15% reply rate comes from our Playbook feature, before you even press the "send" button. Before any outreach, Articuler.ai reads both sides — your background and theirs — and finds the actual shared ground between you. That's what makes the first message land. It's not a template with a mail-merged company name. It's context that could only come from understanding both people. We are like that "guy who knows the other guy".

On stale data — great question. Public profiles do go stale, and we're aware that's a real edge case. Right now we mitigate this by pulling from multiple public sources rather than relying on a single profile, so even if someone's LinkedIn is outdated, their recent activity elsewhere can fill the gap. That said, this is an area we're actively improving — the goal is to flag confidence levels on match data so you know when context is fresh vs. inferred. You can truly see the degree of matching between you and the target individuals on this list.

@stainlu ❤️❤️❤️

@stainlu Means a lot. Shipping speed is the whole strategy this quarter, the fact that the same engine works for hiring, fundraising, and BD off one profile is the part we're proudest of. More coming this month.

@gavin_luo ❤️❤️ @Tripo AI is my favorite 3D generation model

@gavin_luo Bo spent years building datin apps... so the skills transfer lol

@fabian_exner Fabian, this is exactly the design problem we obsess over 🙏

we don't use keyword matching at all. We embed each person's full public footprint, directly into a semantic vector. Matching happens in vector space, not in keyword space.

So the "profile doesn't use expected keywords" failure mode doesn't really apply. Two people writing about the same idea with different vocabulary — "climate" vs "energy transition", "distributed systems" vs "large-scale infrastructure" — end up close in the embedding space because the model captures meaning, not surface words.

We don't search profiles, we match meanings. That's the difference between matchmaking and search.

Caveat: there's still real work in deciding which signals to weight up (behavior vs declaration, recent vs old activity). But the "missing keyword" failure is mostly a keyword-system problem, not a vector-system problem.

Right thing to push on 🚀

@asim_saeed1 Yes, with one caveat. Beta users and first customers are exactly the use case Global Match does well, because you can describe what your product solves instead of searching for a job title — "operators at sub-50-person fintech teams frustrated with [specific problem]" returns a tighter list than any LinkedIn filter combination. The caveat: match quality is sensitive to how specific your disqualifiers are. "Founders interested in fintech" returns noise; the tighter the who-shouldn't-care, the better the shortlist.

@bilal_niaz ❤️❤️ You are more than welcome to give articuler.ai a try!

@bilal_niaz Keyword search asks "who matches these tokens." Intent matching asks "who can move this specific goal forward." They look similar from the outside but produce completely different shortlists. Glad it resonates.

@bilal_niaz Thanks Bilal, it's time for the next chapter for professional networking!

@madalina_barbu ❤️❤️❤️

@madalina_barbu Thank you Madalina!!!

@yehan_xiao Yehan 🙏 Early-stage hiring is the use case we obsess over the most — the best first hires almost never show up in LinkedIn keyword filters. What's the role? Happy to run a sample search and share the playbook on the top 3 matches.

@yehan_xiao Feel free to just leave us one line or one goal about the type of person you are seeking. We can just run it for you and present you the results, and you can see it for yourself!

We have increased the free trial quota for new users, so you have more room to explore and get a real feel for what we can do.

@cruise_chenNiche is exactly where Mira shines. Keyword sourcing breaks on quant and biotech because the signal is in the sub-specialty, not the title. Mira reads JDs at that resolution: stat arb vs market making, wet-lab vs computational bio, mRNA delivery vs protein engineering. That's why AI, robotics, and biotech became our biggest verticals, the deeper the domain, the worse traditional tools perform, and the bigger our edge. Quant's the same architecture. Give Mira a real JD and you'll see a slate same-day from a pool 300x larger than manual sourcing. Try it on your hardest open role.

@cruise_chen thanks for the comments, please see my CTO's feedback.

@cruise_chen 
To add some context — the objective scarcity of qualified candidates is a genuinely difficult challenge, and one that no algorithm alone can solve. It is fundamentally a supply problem. That said, when each role is communicated with greater clarity and specificity, it meaningfully improves the likelihood of a successful match.

What traditional recommendation engines and search engines have failed to deliver, we have built: a results-driven, interactive talent-sourcing Agent. When you experience it firsthand, I am confident it will exceed your expectations. Thank you.

@lakshminath_dondeti One Credit allows you to unlock a candidate who has already confirmed their interest—meaning they’ve expressed enthusiasm for both the company and the position. You can then schedule an interview and wait for the appointment to be confirmed. Thank you so much, I’ll make improvements right away!

@jocky Thank you
Communicate like a seasoned recruiter—one deep conversation, and you’re ready to extend the final interview invitation. That’s all it takes.

You can have the right candidate in hand the same day and send the invitation immediately, instead of ending up with just a shortlist after a hectic search. Simple and efficient.

@jocky You just drew the line we built the company on. Copilot is what you build when you don't trust the model yet. Agent is what you build when you do. The whole point is that you shouldn't be in the loop until there's an actual decision to make, and screening 200 resumes is not a decision, it's a tax. Mira pays the tax. You make the call.

@jocky yes, you are right, the next step should be a background agent !

@dmitry_zakharov_ai many thanks!

@dmitry_zakharov_ai Thanks Dmitry!

@dmitry_zakharov_ai Thank you so much

@ebroms Once a candidate books a call, the experience can be fully configurable by the employer. Some companies prefer an AI-led screening interview first for speed and consistency, while others route candidates directly to a human recruiter or hiring manager. Our goal is to reduce recruiter overhead without making the candidate experience feel robotic or impersonal.

@ebroms When someone books a call with us, they're talking to a real human at the company. A recruiter or the hiring manager, depending on the role. Mira doesn't sit in for the interview.

That's intentional. The moment a candidate agrees to a call, they're making a real career decision, and finding an AI on the other end would feel like getting catfished. People are fine chatting with an AI to confirm the boring stuff. Timing, scope, comp range, whether the role's actually remote. They're not fine pitching their career to a chatbot for 30 minutes, and frankly, they shouldn't have to.

Our split is pretty simple. AI does what AI is actually good at: searching, personalizing, juggling async threads, getting calendars to agree with each other. Humans do what humans are still way better at: reading whether someone's the right fit, conveying what the team's actually like, closing. Candidates get both. Nobody has to pretend to be the other one.

@lokesh_motwani1 Thank you! We look at two separate problems: fit and intent.

For fit, Mira evaluates candidates beyond keyword matching — including trajectory, project relevance, skill overlap, and likely success in similar environments.

For intent, we use a mix of activity signals, responsiveness patterns, and inferred openness to opportunities, so recruiters spend less time reaching out to people who are unlikely to engage.

@lokesh_motwani1 Lokesh, thanks for trying it. You're naming the two problems that actually matter, and most "AI sourcing" tools mash them together. They're not the same.

Fit is: could this person do the job well if they joined? Intent is: would they actually take it if asked? A great candidate who isn't looking is a wasted ping. A motivated one who isn't a fit is worse, because nobody catches it until everyone's already burned hours on interviews. We score them separately.

For fit, we don't match on resume keywords. We reason about it. Which past projects actually demonstrate the role, which gaps are real, which ones a keyword filter would kill but a smart recruiter would push through.

@thea5 Feel free to try it with a real open role. You will find that candidates can be scheduled for interviews the same day. It is an incredibly efficient experience — moving straight to booking, confirming a time on the calendar. It really is that simple.
Thank you.

@thea5 the fastest result we recorded is half an hour

@thea5 generally speaking, we may receive about 10-15 candidates within 72 hours.

@blink_66 You can describe your hiring needs just like you would in a conversation with a seasoned recruiter, and the right candidates end up booked directly on your calendar. This is not automation for the sake of automation. This is what the hiring process was always meant to be. It starts with what the Hiring Manager actually needs, and ends with the right candidate scheduled for an interview.
Thank you so much.

@blink_66 

Thanks! Funny enough, the most common reaction we get is "wait, was that actually an AI?", and not in the bad way. Candidates tell us it felt more specific and thoughtful than 90% of recruiter outreach they get. The design principle is simple: every message is generated per-candidate per-role, references real signals from their actual work, and the candidate can reply with real questions (comp, team, scope) and get real answers back. It's a conversation, not a blast. The bar we hold ourselves to: would a thoughtful senior recruiter on their best day send this? If not, Mira doesn't.

@blink_66 thanks for your question, so far, most of the human felt they are talking to a human recruiter.

@carlvert Thank you for your interest. We will keep improving. The Agent has made such a tremendous difference for us, and we hope it can do the same for many more teams down the road.

@carlvert thanks for your conments, please give it a try and we appreciated any further suggestions.

@carlvert Thanks. Sourcing is the easy half, the rest is where time actually goes. That's the wedge. We'll be here when you're ready to look closer

@yuvraj_xyz This is fundamentally a complex noise-reduction problem. We tackle it by aggregating multi-dimensional data to improve the accuracy of information, all within appropriate and compliant boundaries of course.

Our goal is to surface better, more relevant candidates and bring them into the interview process. For candidates, building their own credibility over time matters just as much. We are continuously exploring and pushing forward. Thank you.

If you have any ideas or thoughts, we would love to hear them. Thank you so much.

@yuvraj_xyz The right question for 2026. Resume noise is no longer noise, it's the default.

Our take: stop treating the resume as ground truth. Mira triangulates against artifacts that are hard to fake, GitHub commits, papers, patents, OSS contributions, actual shipped products, and uses conversational screening to probe depth. Ask a real builder about a tradeoff they made and they go ten minutes. Ask an AI-optimized profile and it collapses in two turns. The asymmetry we're betting on: AI can write a resume, but it can't fake a track record of actually building things. The polish gets you in. The conversation gets you out.

@yuvraj_xyz thanks for your comments ! AI-optimized resumes are becoming the norm, so we don’t rely heavily on resume keywords alone.

At OpenJobs AI, we look much deeper into “builder signals” — things like actual project history, execution patterns, technical depth, consistency across experiences, public work, hiring context, and how candidates communicate/problem-solve over time.

A polished resume can help someone get discovered, but it’s very hard to fake real output, real momentum, and real domain understanding at scale. That’s where our agents focus.

@jinhao_bai2 Spamming candidates is simply the wrong approach. We only surface roles that are accurate and genuinely relevant to each individual. Modeling candidate intent is a complex engineering challenge, and one we are continuously iterating on and exploring.

When information is truly precise and scarce, it carries real weight for the candidate. That is why our response rate consistently outperforms the industry average. We will keep optimizing and delivering more value.

@jinhao_bai2 This is exactly the question that should be asked, and honestly, it's why we exist.

The reason candidate experience is broken isn't AI, it's that recruiters were forced to use templates and bulk tools to keep up with volume. AI done wrong amplifies that. AI done right inverts it. Mira sends fewer messages, not more. Every outreach is gated by a qualification step, generated per-candidate per-role, and rate-limited across our entire network so no one gets hit twice. Candidates can actually have a conversation back, asking about comp, team, scope, before deciding to engage. The candidate experience metric is in our north star, not a footnote. If Mira contributes to the noise, our whole thesis collapses.

@jinhao_bai2 That’s a real concern, and honestly we think the industry is heading in the wrong direction if AI just means “more spam at scale.”

Our approach is to optimize for relevance, timing, and signal quality — not outreach volume. The goal is fewer but much higher-context interactions, where the agent already understands why this opportunity actually matches the candidate.

Long term, we believe recruiting agents should behave more like trusted talent scouts, not mass outbound tools.

@whitney_hong Appreciate it — that’s exactly the kind of workflow we’re trying to unlock.

Right now our focus is less on paid growth and more on building deep product loops inside recruiting workflows. SEO/GEO around recruiter intent, niche roles, and hiring outcomes is definitely a big part of the strategy, especially as the agent gets better from real usage data. We think distribution in recruiting will increasingly come from performance, not just traffic.

@whitney_hong Thank you for your feedback and guidance on our direction.

The multi-agent collaborative model, built around outcomes and data, changes everything compared to traditional approaches. It brings us closer to the nuanced judgment of a seasoned recruiter, while being fairer and more efficient at the same time.

We believe methodology and approach are everything. We also believe great products speak for themselves through word of mouth. So our focus stays on continuously raising the bar on our service and product, and delivering real, tangible results for our clients and users.

We welcome more people to come and try it out. The more feedback we receive, the faster our Agent and our team can improve. Thank you.

@whitney_hong Three weeks of manual search beaten by an agent is exactly the wedge. Thank you for stress-testing it on a hard role, that's the signal we actually care about. On distribution, you're half right. SEO/GEO around recruiter intent is the obvious play, and yes, we're running it. But the bigger bet is agent-to-agent: Mira is exposed via API and MCP, so she shows up inside Claude, GPT, and any internal copilot a recruiter already uses. "Hiring workflow" stops being a destination, becomes a capability. Which role broke your manual search? Curious. 👀

@zabbar till now, there are more than 100 startups tried our poduct, the feedabcks are very positive ,espsecialy from some CTOs.

@zabbar SMBs are our target clients

@yehan_xiao 
Have an efficient conversation with the Agent，everything becomes simple and clear! A new way of recruiting has begun.

@yehan_xiao please give it a try! thanks for your comments

@yehan_xiao Founder hiring is brutal, you're hiring while doing everything else. Sourcing is the easy half. The follow-ups, the scheduling, the chasing, that's where founder time actually goes, and that's the part we built Mira to take. DM me when you're ready, I'll personally help you set up the first role.

@luke_pioneero 
Thank you very much! We will continue to support startups and look forward to our startup program.

@luke_pioneero thanks luck for your comments!

@luke_pioneero Thanks for the good wishes！

@cynthia220 We’re more than just a sourcing tool. we deliver real, efficient interview bookings with the right candidates.

Booking is our newest feature; stay tuned for even more powerful outreach and interview scheduling.

Welcome to continue the discussion.

@cynthia220 thanks for your comments!

@cynthia220 Exactly. Sourcing without scheduling is half a product. The reply isn't the bottleneck, the calendar Tetris after it is. Thanks for naming the wedge better than our marketing page does.

@sandy_liusy 
Thank you
Top-tier headhunting firms have already used us to place their technical and marketing leaders. We recommend trying it for both engineering and sales roles, you’ll see outstanding results.

@sandy_liusy so far, i would like to say both are ok .

@sandy_liusy Thanks! Technical is genuinely where Mira shines, AI, robotics, and biotech are our largest verticals today, and Mira reads JDs at sub-specialty resolution (not just "ML engineer" but RL vs CV vs systems). Counterintuitively, the harder and more niche the role, the bigger the edge over manual sourcing.

What kind of role are you hiring for? Happy to run a quick test on a real JD if you're curious. 👀

@linglistack Some parts of the process require human-in-the-loop involvement—only to confirm the candidate profile and schedule the interview. Focus solely on the key decisions, not on wasting time in ineffective steps.

@linglistack Yes, you can do the candidate review before automating the following process

@linglistack really depand on what's your needs

@hello_leo Recruiting remains a significant challenge — one we're committed to tackling head-on, for both our team and our AI Agent.

@hello_leothanks leo for your comments !

@hello_leo we will do it better!

@thekrew We think the personalization layer is the product. Mira doesn’t just blast recruiter-written templates at scale — it generates candidate-specific outreach based on profile, experience, signals, and role context, while still keeping recruiters in control of tone and constraints. The hard part is maintaining a quality floor as volume increases, so we optimize more for response quality and relevance than raw send volume.

@thekrew Sharp question, Vamshi. You're pointing at the exact failure mode that killed the first wave of "AI sequence" tools.

Our framing: the personalization-volume tradeoff is a symptom of treating outreach as a writing problem. It isn't. The real bottleneck isn't generating words per candidate. It's having something specific and true to say to each one that the recruiter couldn't have written themselves at scale.

Mira writes per-candidate, never from templates. But the part that actually matters happens upstream of the message. Before any outreach is generated, the Job Brief Agent and Search Agent produce a structured fit narrative for each candidate: which signals in their profile map to which requirements in the role, what's core versus adjacent, and what would plausibly motivate this specific person to take a call given their trajectory and current context. The message is just the surface rendering of that reasoning.

The reason quality doesn't collapse at volume is that we deliberately don't optimize volume. What we optimize for is qualified interviews, not messages sent or even reply rate. That changes the entire shape of the system. We'd rather contact 30 candidates with a 40% positive response rate than 300 with 4%. Unit economics are healthier, candidate experience stays dignified, and employers waste fewer interview slots.

The honest tradeoff we accept: Mira is slower per candidate than a template blaster. For technical and specialist hiring, which is where we're focused, that's the right side of the tradeoff to be on.

Would love to compare notes on how the sales-side version of this problem looks for you. The shapes seem to rhyme.

@musa_molla I love the idea of an AI code reviewer that can catch what others miss - it's a game-changer for dev teams. Finding warm leads who've already shown interest in similar products has been key for my own launches, and I'm curious, what's your strategy for getting Graphbit PRFlow in front of the right developers and DevOps teams? Are you targeting specific communities or forums where code review is a major pain point?

@musa_molla The deterministic angle is the most underrated part of this pitch - and I think you're underselling it. Consistency isn't just a UX nicety; it's actually the precondition for trust in any review tool. Teams can't build workflow around something that behaves differently run to run. That's the real reason AI reviewers get abandoned, not the noise.

The cross-file dependency tracing is where I'd love to understand more. Diff-level review is a solved (if noisy) problem; but function-level change propagation across a codebase is genuinely hard, especially at scale. How does PRFlow handle large monorepos or deeply nested dependency graphs? That's where I'd expect the failure modes to show up, and it's also where the 14 vs 0 security catch story gets even more compelling if you can speak to it.

One thought on positioning: 'deterministic baseline reviewer' is technically precise but might undersell the outcome. You're essentially saying 'your senior engineer's first-pass, codified and automatic, every time', that's a different emotional register than 'reviewer.' Something to consider as you scale past early adopters into teams that need to sell this upward.

Congrats on shipping and putting the benchmarks in public. That's a confident move most tools avoid.

@musa_molla Yes. Very noizy. You need a master PR reviewer jsut to review the AI reviewers 😅.... Is graphbit free for public repos? id love to try it on one particular public repo thats launching soon on PH https://github.com/eoncode/runner-bar/

@1mirul Exactly the balance we were going for. PRFlow handles the repetitive stuff so the senior devs can focus on what actually needs their eyes. Thanks for getting it

Thanks, @1mirul. That’s very much the design philosophy behind PRFlow. We’re not trying to replace human review, but to automate the repetitive process so engineers can focus on architectural decisions, business logic, and edge cases. The goal is to make review workflows more consistent inside GitHub while keeping humans in control of the final judgment.

@tanjum That's exactly the balance we were going for, baseline handled automatically so engineers stay focused on what needs human judgment.

On larger PRs and multi-file changes: PRFlow traces the exact function that changed and follows its dependencies across files in the same PR. Token budget is managed so larger PRs don't get shallow reviews. The depth stays consistent regardless of PR size

@tanjum Thanks. For bigger PRs, PRFlow builds context in layers using our own context engine. It extracts structured context from each changed file, enriches that with cross-file dependencies, and then reviews the PR as a whole rather than one file at a time. For very large PRs, it also uses token budgeting and file prioritization so the review stays focused and useful.

@vikramp7470 Coin toss, that's exactly it 😄 That frustration is why we built it this way. Same PR, same review, every time. Thanks for the support!

Totally agree, @vikramp7470 . That’s exactly the bar we’re aiming for. Deterministic behavior makes the review process much easier to adopt because teams know what kind of feedback to expect each time. Trust is hard to earn with AI tools, so consistency was a big design priority for us.

@byalexai Thank you for supporting us today, means a lot to the whole team 🙏

@aanchal_dahiya GraphBit is model-agnostic by design and on-prem deployment is supported. For data-sensitive use cases, the architecture allows local tokenization before any LLM contact. Self-hosted models including local Llama setups can be connected. Happy to walk through the specifics if you want to share more about your setup.

@campritchard That's exactly it, the diff is just the entry point. The bug lives in what the change touches downstream. Glad that landed clearly 🙏

@bilal_niaz Exactly that. The diff is just the surface, the bug usually lives in how the change connects to everything else. Appreciate you getting it.

@bilal_niaz Thanks. Really appreciate that. That was one of the biggest things we wanted to solve, moving beyond line-by-line diff comments and giving the reviewer enough surrounding context to catch architectural or cross-file issues that would otherwise get missed.

@jason_shen3 This is the hardest problem in the space and you've articulated it perfectly.

Honest answer: right now PRFlow learns from explicit corrections, when your team flags something as intentional, it stores and applies that. So a new pattern gets reinforced when engineers actively confirm it in review conversations.

The drift vs regression detection you're describing - knowing when the team is intentionally evolving vs accidentally breaking convention - that's a deeper layer we're working toward. The memory architecture is built to support it but we're not claiming to solve it fully yet.

Appreciate you pushing on this. The teams that think at this level are exactly who we're building for 🙏

And congrats on @articuler.ai, Matching on intent across 980M profiles is a genuinely hard problem, the playbook feature especially, turning a cold connection into a warm conversation before it even starts. Rooting for you on launch day..

@peyton_perez Thanks. It posts as a bot on the PR, with a review summary and inline comments when needed. Not just as a check summary.

@peyton_perez Exactly, inline comments directly on the PR, not just a check summary. So your team can reply, discuss, and resolve right in the thread where the code lives

@asher_luca Thanks. Right now, PRFlow is GraphBit cloud-based rather than self-hosted. The review orchestration runs through the GraphBit cloud.

@asher_luca Cloud-based for now. Self-hosting is something we hear interest in, especially from enterprise teams. Good to know it matters to you, noting it

@antonio_manuel1 Thanks. The exact time depends on file count, PR complexity, and how much cross-file context needs to be pulled in, but the architecture is built to keep even larger PRs in the minutes range(0-3 minutes) through single-pass review and token-budgeted context handling.

@alexis_rodriguez7 Mostly no. PRFlow filters out a lot of low-value review surface by default, including dependencies, build artifacts, binary/non-code files, and it also supports repo-level ignore rules for auto-generated or vendored paths. So our benchmark focus was on reviewable PR code, not noise from vendored or generated files.

@alexis_rodriguez7 Good question. Our benchmark used real open-source PRs, generated files and vendored dependencies are automatically detected and skipped. PRFlow only reviews code your team actually wrote

@emily_carter18 , Thanks. Yes, within a single PR that’s exactly the kind of cross-file change PRFlow is meant to handle. It analyzes the PR holistically, so a function signature change across 10 files is reviewed as one connected refactor rather than 10 unrelated edits, subject to the PR’s file-size limits.

@barnaby_lloyd Thanks. In PRFlow, noise means low-value feedback like trivial nits, duplicate comments, or findings below the repo’s configured threshold. A real issue is something actionable that affects correctness, security, performance, maintainability, or cross-file behavior.

@olivia_bennett7 Yes, for monorepos inside a single repo. PRFlow uses cross-file dependency analysis and repo-level context, so it can reason across multiple projects in the same PR, with practical limits on very large PRs.

@olivia_bennett7 Within a single repo it handles cross-file dependencies well out of the box. Full cross-project monorepo support is something we're working on.

What's your setup? Happy to tell you exactly what PRFlow would and wouldn't catch for your case

@wyatt_carter XSS vulnerability that spanned three files- a Ruby controller, an HTML template, and a JavaScript file. The bug only existed in how they connected, not in any single file in isolation.

Every other tool we tested on the same PR found zero issues. PRFlow caught it because it traces the function that changed and follows its dependencies across the whole PR.

That one finding is what convinced us we were building something genuinely different

@owen_shaw2 Thanks, Owen. Yes, partially. PRFlow reuses repository memory and previously indexed context across PRs, so it avoids starting from zero each time. That helps reduce repeated context-building work, while the current PR still gets a fresh review.

@owen_shaw2 Fresh context per PR by design, stale context from previous merges would actually hurt accuracy more than help speed.

What persists across PRs is the memory layer: team corrections, false positive flags, and coding preferences. That's what improves over time, not the runtime.

Latency sits at 1 to 3 minutes regardless. Consistency has been the bigger win than speed for most teams 🙏

@boyuan_deng1 Great question. We don't use a rule engine, that's actually a key part of how PRFlow avoids noise in pull request security auditing.

Instead of predefined rules, PRFlow uses context-aware pull request analysis. It extracts the exact function that changed, pulls in cross-file dependencies, and retrieves past feedback from your team's correction history. The AI then evaluates against that full picture, not a checklist.

What reduces noise in practice: if your team has previously flagged something as intentional, PRFlow stores that and stops raising it. Over time the signal-to-noise ratio improves automatically without you writing a single rule.

The honest answer is no system is perfect on day one, but the memory layer is what separates it from tools that feel like a coin toss every PR. Happy to dig into specifics if you have a particular case in mind.

@boyuan_deng1 Thanks. In PRFlow, noise means low-value feedback like trivial nits, duplicate comments, or findings below the repo’s configured threshold. A real issue is something actionable that affects correctness, security, performance, maintainability, or cross-file behavior.

@imogen_wallace Yes. PRFlow analyzes the PR holistically, not file by file, and adds cross-file dependency context during review. That makes it better at finding issues that span several dependent files.

@imogen_wallace Yes, that is the core of how PRFlow works. Most tools do diff-level scanning and miss issues that live in connected files. PRFlow does cross-file bug detection in GitHub PRs by tracing the actual function that changed and following its dependencies. In our benchmark we caught an XSS vulnerability spanning a Ruby model, an HTML template, and a JavaScript file - classic case of automated XSS detection that a diff-only tool would never reach. Reducing technical debt with AI code review only works if the review actually sees the full picture. Happy to share the GitHub link to that specific finding if useful.

@abod_rehman Yes, it can run on every push to an open PR, not just when the PR is first opened. Right now PRFlow triggers on PR open, on new commits pushed to the branch, and when a draft is moved to ready for review.

@abod_rehman Thank you! PRFlow triggers on PR open and every push to an open PR, so automated pull request review happens continuously throughout the lifecycle, not just at the start. Every new commit gets a fresh pass. No gaps in coverage

@lokesh_motwani1 Great question and glad you're going to try it on Badge.

The single pass doesn't mean one giant context window. PRFlow extracts only the relevant function scope and its cross-file dependencies before sending to the model, so the actual input is tight and focused, not a full repo dump. That's what keeps the middle from getting lost.

Token budgeting handles the rest, larger PRs get prioritized by semantic significance rather than being truncated blindly.

Important thing is, no system is perfect on very large PRs, but the extraction step before the model call is what keeps the signal-to-noise ratio high

@asim_saeed1 Thanks. Yes, it supports Python. PRFlow is not limited to JS/TS, and Python is one of the main codebase types we’ve been building and testing it around. Also, just to clarify on pricing, our plans are currently token-based, so when you buy a plan you get a graphbit coin allocation rather than being charged separately per individual use.

@asim_saeed1 Solo devs reviewing their own code is actually one of the use cases we care most about, you're the ones with the least margin for error and the least backup.

Python is fully supported and one of the stacks we've tested most heavily. The auth bypass we caught in our benchmark was in a Python codebase.

Coin-based means you buy what you need and use it at your own pace. No monthly seat pressure

@gaius_loxley Not yet, PRFlow currently triggers on PR events, so it works on open and updated PRs. Retroactive auditing on closed PRs is something we've heard interest in. Good signal, noting it

@daniel_harris11 Yes. When your team replies to a PRFlow comment, "this is intentional" or "we prefer this pattern" it stores that and applies it to future reviews automatically.

No manual training setup. It learns from how your team actually works

@daniel_shoshani1  def. a game changer for DTC brands. how does it handle technical accuracy for moving parts vs static objects?

@daniel_shoshani1 I love the idea of bringing AI-generated products to life, the "literally" part of your tagline really stands out to me. Finding warm leads has been key for my own launches, I've had success targeting users who have upvoted similar products that merge tech and design. What's your strategy for getting Genpire's AI-created products into the hands of customers, are you planning to partner with existing manufacturers or distributors?

@daniel_shoshani1 Every shortcut on the surface only feels like magic because of the stack underneath holding it up. So proud to see this finally out in the world congrats on the launch, team!

@myurtsever The backbone of the Genpire machine!

@myurtsever cong!

@esmatnawahda that "worst day" framing is the exact mindset I steal every time I sit down to hammer out a new test. The real reason I'm stuck in the QA and marketing infra weeds is because we made a pact on day one: if it doesn't clear that bar, it doesn't ship. I’m incredibly proud of where we’ve finally landed. It’s a massive day for the whole crew

@olumidegbenro Thank you, Olumide!

Thing is - we're in the design-to-manufacturing business, interesting to see that more than 60% of our beta users already have their sourcing and supply chain all sorted out, while Genpire plays a role in their planning, design and specs workflows, in parallel with allowing them to manage the sampling process and sourcing through our agentic sourcing interface offered both for new comers who wants to use our built-in, vetted network of factories - or their own by inviting them to collabrate.

Container house are naturally on a later stage (and plenty of players in this space) - we might launch this on PH sometime during 2027 🏭🪄🍠

@musharofchy Its sure is! We're applying what's good in vibe-coding, into the design, specs and manufacturing workflows of consumer goods. Challenging, but pretty usefull for both non-experienced indie makers, up to product and design teams!

Any idea for a real product? We'll share a free AI powered tech pack for you to use!

@musharofchy Exactly the comparison we love! And honestly it shaped how we thought about the architecture from day one.

With Lovable, the "compiler" is code. With Genpire, it's a factory-ready tech pack. That sounds similar but it's a fundamentally harder output to get right. Code either runs or it doesn't. Manufacturing specs need to be accurate in dimensions, materials, tolerances, and structure because a real factory is on the other end.

That's the engineering challenge that gets me out of bed every morning. Really glad it's resonating!

@madalina_barbu Thank you, Madalina, any product in mind? We'll share with a free tech pack to get it made :)

@madalina_barbu Thanks

@madalina_barbu Thank you

@noa_dichno Hi Noa!

Good to have you here!

@german_merlo1 Pricing and business model for AI-native platform like Genpire are such a huge space! We offer a 3-tiered monthly plan (with annual discounts), that usually suits the needs of indie-makers, DTC brands and large enterprise consumer goods teams alike. We also offer a team plan soon, with SKU based pricing, but more on that later.

Appreciate the comment!

Best
Daniel

@jdsalbego Hey J.D., huge congrats on the launch. With OWASP ASI 10/10, how do you recommend founders prioritize between runtime monitoring vs. the Verification API for early detection of shadow agents?

@jdsalbego Many congratulations on the launch, J.D. :)

Thrilled to see ClawSecure on The Pitch leaderboard. I am rooting for it since its first launch!

Everyone is building OpenClaw AI agents, there's hardly any security solution for them. Hence this is a refreshing + critically important category to pioneer.

@divyanshu_kandpal Great question. Not every code change is malicious. Developers push legitimate updates, dependencies get patched, skills evolve. When Watchtower detects hash drift, it triggers an automatic full rescan through our 3-layer audit protocol. The updated code gets analyzed the same way a fresh install would: our proprietary engine evaluates whether the changes introduce actual threat patterns like C2 callbacks, credential exfiltration endpoints, or permission escalation, versus benign updates like bug fixes or feature additions.

The key is context-aware intelligence. Our engine understands the difference between a skill legitimately using system-level capabilities (which is standard for any useful agent) and a skill abusing those same capabilities to exfiltrate data or execute unauthorized commands. A dependency update that patches a vulnerability scores differently than one that introduces an obfuscated payload. The rescan produces an updated Security Audit Report with the new risk score, so users can see exactly what changed and whether the change made the skill safer or more dangerous.

@le_ng_c_dan_nhi "Boring but necessary" is the best compliment a security product can get. The boring infrastructure is what everything else runs on top of. Nobody thinks about antivirus until they need it, and by then it's too late.

And you're right, once agents are touching real user data, email, files, credentials, payment tools, the blast radius of a compromised skill isn't theoretical anymore. That's exactly why we built runtime monitoring beyond just scanning. Knowing a skill was safe when you installed it isn't enough. You need continuous visibility into what your entire agent environment is actually doing. Appreciate the support!

@kate_ramakaieva That "I didn't realize" moment is exactly why we built this. Most people have no idea what their agents are actually doing until they see it laid out in a report. Elevated permissions hiding in plain sight is one of the most common findings across the 10,000+ agents we've audited.

Glad the scanner delivered. And if you want to go deeper than individual scans, the runtime monitoring dashboard maps your entire agent environment, every permission, every connection, every blast radius, so nothing stays hidden. Thanks for the kind words on the pitch, appreciate the support!

@artstavenka1 Really appreciate that. The "code is the attack" framing came directly from watching what happens in an ecosystem where skills ship with full system access and no permissions model. It's not a runtime anomaly when the code itself is the weapon.

To your question: yes, we cover both. The pre-install scan resolves the full recursive dependency tree and checks for known CVEs, compromised packages, unpinned semver ranges that are vulnerable to hijack, and typosquatting on known packages. Watchtower then monitors for hash drift across the entire skill codebase, so if a transitive dependency gets compromised in an update, the hash change triggers an automatic rescan through the full 3-layer protocol. That's actually one of the sneakiest attack vectors in the ecosystem: the top-level skill code stays clean while a nested dependency quietly introduces the payload. We catch both layers.

@thamibenjelloun Thanks!

@divya_kothari1 False positive rates are low across our platform because of how the detection architecture is designed. Our proprietary engine runs context-aware intelligence that classifies threats based on how AI agents actually operate, not generic code patterns. It differentiates legitimate system-level capabilities like clipboard access, filesystem operations, and shell execution from genuine exfiltration and malicious behavior by analyzing the full behavioral context: what file the pattern appears in, how data flows through the skill, whether external endpoints match known malicious infrastructure, and whether the behavior aligns with what the skill declares it does.

Beyond static analysis, our AI-powered runtime monitoring adds a completely different detection dimension. It continuously analyzes metadata telemetry across your entire agent environment, every skill, MCP server, CLI tool, and configuration, using LLM-driven threat classification to score risk, detect behavioral anomalies, and flag deviations in tool call patterns. When you're correlating declared permissions against actual runtime behavior and measuring that against a dataset of millions of audited agents, the signal-to-noise ratio improves significantly. Static analysis tells you what code could do. Runtime behavioral analysis tells you what it's actually doing. The combination is what keeps false positives low and true detection high.

@iamanantgupta Thanks! Slack integration is on our near-term roadmap and one of the most requested features from our community. Right now Watchtower alerts surface through the runtime monitoring dashboard in real time and via email and Telegram notifications. The detection infrastructure already generates the events the moment hash drift or a behavioral anomaly is caught, so adding Slack and Discord as notification channels is a straightforward build on top of what's already there. It's coming soon. Appreciate the feedback, it helps us prioritize.

@juan Thanks! The honest answer is usually data shock. Someone scans a skill they've been running for months, expecting a clean report, and discovers credential exfiltration patterns or shell execution they had no idea was there. That moment shifts everything from "I should probably look into security" to "what else is running in my environment that I haven't checked?"

The second trigger is realizing that manual review and version pinning only covers what you can see at one point in time. 22.9% of skills in our dataset changed their code after install. A skill can pass every check on day one and quietly mutate on day five. Once users experience that personally through Watchtower

flagging something they already trusted, the need for continuous monitoring clicks immediately.

The first week is straightforward. Most users start with the free scanner to audit everything they're currently running. That takes an afternoon since each scan is about 30 seconds. They see their Security Audit Reports, identify what's clean and what needs attention, and Watchtower starts tracking everything for code changes automatically.

From there, the users who are running agents in any real capacity quickly move into runtime monitoring. One command installs the daemon, and suddenly they have full visibility into their entire agent environment: every skill, every MCP server, every CLI tool, permission maps showing blast radius, configuration audits, and AI-powered risk scoring across everything. The dashboard gives them a single view across all their tracked agents with real-time alerts instead of manually checking individual reports.

The shift from "I scanned a few skills" to "I can see my entire agent environment and what every component is actually doing" is usually what converts free users to paid. That's by design. The free tools show you the problem. Runtime monitoring shows you the full picture and keeps watching it continuously.

@zach_lloyd  I love the idea of an agentic development environment, especially one built with the community - it's amazing to see collaboration like that. What's your strategy for getting Warp in front of the right developers, and do you think leveraging communities that have already shown interest in similar open-source projects will be a key part of that? Finding warm leads has been crucial for my own launches, and I'm curious if you're taking a similar approach with Warp.

@zach_lloyd  the prompt already takes longer to write than the diff takes to read on solo agent work, and that's with the codebase in my head. spec-and-verify is what i'd watch when community contributors without that context start handing specs to Oz. specs go bad upstream and Oz can't catch what wasn't asked for.

Thank you @chrismessina! 🙌

Totally agree, and it's been super exciting to see what the community has been building and adding to Warp. Over the past 2 weeks, we've continuously been making changes to our internal processes so we can be on top of the repo. It's definitely something that we expect to evolve so we can get those PRs merged in fast and give a great experience to our contributors.

@fmerian absolutely 🙌

@brainystudy totally agree, it's been very important to us that our process scales, and the Oz agent managed workflows have been working out very well.

Re: BYO-endpoint, we're currently working on adding support and is a high-prio item on our immediate roadmap. Expecting it to land in the next 1-2 weeks. You can also check out this discussion for more details: https://github.com/warpdotdev/warp/discussions/9619#discussioncomment-16831279

@rivra_dev Great question! Developer control is important and keeping humans-in-the-loop is what makes this system more valuable. Human discretion comes in at a couple of places:

1. Maintainers get to decide whether issues are complex enough to require specs or straight-forward enough to go straight to code. This keeps the decision about complexity and goals in the hands of human operators.
2. All the agents are flexible and rely on repo-specific skills that outline how they should triage, write specs, and review PRs. This let's each repo dictate its priorities and goals in skill files that the agent respects.
3. Oz can respond to maintainer requests on any PR, allowing operators to quickly jump in and steer PRs from any contributor with Oz based on their priorities. Our team uses this to carry PRs to the last mile with fine-tuned adjustments all the time.

@ytubviral So, the interesting thing about Warp is that it started out as a terminal and evolved the agentic features on top. We've got a dedicated terminal subagent that's really good at working with commands that are launched by the agent and processing their outputs. Warp also treats each command execution as a "block" that you can capture as explicit context into an agent request. I use this all the time to pipe build errors or logs in to the agent to analyze. If you're curious to see all this in action, I'd definitely recommend trying Warp out yourself and seeing how it plugs into your terminal workflows.

@abesh_thakur I love how Weavable is tackling the challenge of giving AI agents persistent work context - it's a game-changer for efficiency. The concept of persistent work context really resonates with me, especially with the tagline highlighting its importance. How are you planning to reach potential customers who have already shown interest in similar AI-related products, I've found targeting warm leads who have upvoted similar products to be crucial in my own launches?

@abesh_thakur the change log is an excellent idea. Finding ways to provide contexts to agents is so valuable. Congratulations on the launch!

@nerijusrimdzius Thanks, and a great question!

Weavable structures context before it hits the MCP endpoint. We rank it, denoise it, and resolve the connections that carry the most signal, so the downstream model gets a high-quality, ready-to-reason-over view rather than raw records to make sense of.

One thing we've noticed: because of how we construct the context, models in the same class tend to reason about it in similar ways. The structure is unambiguous enough that interpretation converges. Different classes of model still unlock different capabilities on top of that, but the floor moves up everywhere, and the variance within a class drops noticeably.

Curious where you've seen the biggest gaps across the three you're running at Faindo. That's exactly the kind of cross-model signal we want to be informed by.

@nerijusrimdzius Thanks for sharing your build journey here. Since you brought up such an interesting (and real) issue with multiple models interpreting context differently, how have you been handling it so far at your end? Any good results/hacks that you swear by?

@seyed_danesh Thanks Seyed! Yes, this is one of the (many) things that Weavable is designed to fix.

You're describing the iterative-retrieval loop: pull, reason, pull more, reason again. Each round trip costs latency and tokens, and with direct MCPs across multiple sources it compounds fast.

Weavable does that work upstream and continuously. By the time the agent queries, the connections are resolved, the signals are ranked, and the change history is already in the graph. The agent typically gets what it needs in one query against a context, not four against four data sources. Fewer round trips, lower latency, and roughly a tenth of the tokens.

In our testing we've not only found the responses to be of better quality but also found that the downstream model/agent becomes better at adhering to instructions too!

@grantmac_ Thanks! Indeed, nothing about data is every static!

On the tokens: pulling raw data into the context window costs you twice. Once on ingestion, then again on reasoning, while the LLM connects records, sorts by recency, and figures out what matters. Weavable's graph already knows the relationships and what changed when. The agent queries for the specific signals it needs, and the model only reasons over those.

The 90% is what we see on realistic workflows like pre-meeting briefs, renewal analysis, pipeline summaries, compared to the same thing built on raw MCP calls.

@grantmac_ thank you for taking a look, and for the encouragement!

@iamtherealcmk Thanks Conor! Context governance is the right question to be asking as more sensitive work moves through agentic systems.

Two layers to how we handle it.

First, all connections to source apps are OAuth and read-only, tightly scoped. Weavable only sees what your OAuth scope permits.

Second, agents don't connect to your data sources directly. They connect to contexts you've defined in Weavable: curated views with explicit data scopes. This set of HubSpot pipelines, those Slack channels, this Notion space, scoped to the user or team that should see it. Board discussions, HR, commercial terms each live in their own context with their own access rules. The governance boundary sits at the context layer, where you can model the actual sensitivity structure of your team, not at the data source where it's brittle and easy to overshare.

Every query against a context is logged too: which agent, which user, which signals were retrieved. So you get an audit trail that matches the governance model.

What's the shape of the hacks you've been running? 😅

@iamtherealcmk to add to this - you are absolutely thinking about the right things. There are some pretty good strides being made to tackle governance overall, but not at the pace at which it needs to keep up - and it's not a matter of just shipping more dashboards.

If you do have any working "hacks" that you are happy with - do share!

@odeth_negapatan1 Great question - it's on point.
Every app is connected to a user's context through OAuth, which means for teams using shared contexts, the underlying permission model is never changed - whatever they were able to see originally is what they can see using Weavable, nothing more, nothing less. This is a critical area of work for all things agentic, so clear UX and scoped context creation has been a pretty major focus for us as we build this.

@fabian_exner Thanks Fabian! That decision sits with you, not us. A context in Weavable is something you define and curate, so you decide whether a slice of your work data is worth standing up as a reusable view or just queried against a broader context.

In practice, two patterns: workflow-shaped (recurring jobs like renewal analysis or pipeline review, where the same signals get queried on a cadence) and exploratory (you query a broader context, find what matters, then decide if it's worth crystallizing into its own).

Because the graph underneath is always live, contexts are easy to create, modify, and clone as you learn what the agent actually needs.

@fabian_exner Thanks for the support!

@dyballnoble Thank you! "Live infra rather than a dump or a freeze" is a sharper way of putting it than we've managed ourselves 😀

The whole bet behind the activity graph is that context has to be a live, structured view of what's happening, not a dump of static data handed to the model where reasoning happens at a language level. Work is about things happening, not just the end-state artifact. Looking forward to hearing what you think once you're in.

Thanks so much for your support @huisong_li!

@huisong_li Thanks for your support - means a lot to us! What kind of AI powered workflows have you been getting the most mileage out of for your day to day?

@lewisrogers Thanks for flagging this Lewis! To be clear, this was not us, but we really appreciate the good faith outreach to bring it up here rather than just ignoring it. If you can DM me the LinkedIn profile, we can follow up with PH so they can act on it.

@lewisrogers Took a quick look at ReadySetLaunch as well - congrats on building something that looks genuinely useful too!

@maxcameron Excellent question Max, and thanks for the support!
There are a few ways to handle what you mentioned. We think of solving this through a combination of

a) a changelog-based graph that keeps its context relational and up to date and

b) being able to reason across these scoped contexts - for example, understanding the real state of a deal based on not just the last meeting notes left there, but continuing conversations on Slack threads internally

These directionally already go a long way in determining the state of affairs, and we eventually have to get to a, as you called it, a system of context. You do raise a great point about standardization overall - lots to think through!

@tjclayton great point, but this is also where building a changelog based graph really helps - in fact, being able to capture the fast moving codebase for example is essential because static snapshots, or multiple queries (like you hinted at in your case) isn't going to get you reliably there or at a much greater cost.

@brucewalker_ Great question! Since the apps connect to Weavable using OAuth, the system can only access and process data that a specific user is already permitted to see across contexts within the parent applications.

On the other hand, if you want to use a global admin to share everything within a given set of tools across the organization, you can do so without having to reconfigure the entire system.

I think this approach makes governance across the AI stack much more manageable, and allows the system to scale.

@suhasmotwani Thanks Suhas!

@pengspirit666 Excellent question, and something we see quite often when working with larger companies.
The control itself is defined when you curate a context. That's where you set which data scopes are in, which are out, and who the context is available to. Cross-tenant boundaries can be enforced both there and at the OAuth layer, depending on which connections each side of the boundary should be able to reach. Additionally, every query against a context is logged too: which agent, which user, which signals were retrieved so the entire flow becomes auditable.

@pengspirit666 thanks for the great question and support!

@andreyv 🚀🚀🚀

@soraiadev  I love the concept of inspecting and editing any website's design with MiroMiro v2 - the idea of having that level of control is really intriguing. The tagline "Inspect, edit, and export any website's design" resonates with me, especially for design-focused projects. How do you plan to reach designers and developers who could benefit from this tool, and have you considered leveraging the networks of users who've already shown interest in similar products, like I have with my own launches by targeting warm leads?

@soraiadev This feels like the natural evolution from inspect tool to design-to-code bridge especially the 20 seconds → component loop is the real unlock here.
If the exports stay clean in real-world messy sites, this could become a daily driver for fronted workflows ⚡

@vikramp7470 Thank you Vikram! 🙌 That's exactly the feeling I was chasing with the live editor. As a front end dev I spend so much time tweaking tiny values in DevTools, then losing them on refresh and having to redo it all over again. MiroMiro is basically the tool I always wished I had open in another tab.

@farid_sukurov Thank you so much, Fred! This means a lot coming from you.

I see you as a huge builder and someone I really look up to, you just know so much about this whole world, from building products to scaling and marketing them.

Really grateful for the support 🙏

@campritchard Thank you so much Cam! 🙏

That's the main reason I built this, giving AI tools a real visual reference is the perfect way to put it.

As a front-end dev myself, it saves so much time, I really think this is how AI tools should fit into our workflows.

@ajaypatel9016 Thanks Ajay 🙌

MiroMiro exports the code of any section you inspect, not pre-built components. For simple sections (hero, pricing, CTA) the output is close to production. For full landing pages it's more of a starting point.

The workflow I'd actually recommend isn't "export and ship" but rather "export and prompt". Pass the code to Claude or Cursor and let the AI handle reusability, refactoring, responsive tweaks. MiroMiro becomes the visual-to-prompt bridge, so your coding agent can build with a real reference instead of making things up it can't see.

That said, I'm always improving the export-to-code side since it's the most complex part of the product!

@dmytro_krasun Thank you a lot Dmytro!

@zaczuo I love the promise of Snapseed 4.0 being "seriously better" - what specific features do you think will resonate most with users? For my own launches, I've found that targeting warm leads who have already shown interest in similar products is key, so I'm curious, what's your strategy for reaching users who are already familiar with photo editing apps? Will you be leveraging Google's existing ecosystem to drive adoption?

@rohanrecommends I love the idea of chatting with my spreadsheet - the tagline "edit cell with natural language" really resonates with me as someone who spends way too much time formatting cells. Finding warm leads, like people who've upvoted similar productivity tools, has been key for my own launches, and I'm curious to know how you're targeting users who are already familiar with Google Sheets. What's your strategy for getting this in front of power users who could really benefit from this level of automation?

@dominic_pi_dunyer What's one real-world task or workflow where you've seen the biggest wins from converting DOM to JSON (like time saved or accuracy boost)?

@dominic_pi_dunyer I love the idea of killing the 'Token Tax' - it's a major pain point for many users. Your claim of 90% cheaper agents is really intriguing, how do you plan to reach the web3 communities that would benefit most from this solution? Finding warm leads who have already shown interest in similar products has been key for my own launches, I'm curious to know if you're targeting specific forums or groups to spread the word.

@zabbar Yep, we have run many tests and the anonymized results are on our website under the 'Benchmarks' page. Hope this helps.

@christian_knaut That would be the SDK.

@christian_knaut Hi there, here are a few ways that we deal with the issues that you described.

1. Handling Client-Side Rendering (CSR) & SPAs

Web Speed doesn't just scrape raw HTML. When you use interpret_page(js=true) or

evaluate(), it spins up a full Playwright-driven browser engine.

- Hydration Wait: It executes the site's JavaScript, waits for the application to mount,

and only then performs the mapping.

- State Awareness: Tools like wait_for_element and wait_for_url allow the agent to pause

until the client-side router has finished loading the specific view.

2. Bypassing Bot Detection

Standard scraping libraries often fail because they use "clean" environments. Web Speed

allows the agent to attach to your real browser (via CDP):

- Real Fingerprints: It inherits your active sessions, cookies, and hardware

fingerprint.

- Human-Like Interaction: fill_field(use_keyboard=true) simulates actual keystrokes

rather than just setting a .value, which bypasses many "trusted input" checks used by

modern anti-bot layers (like those on X or Amazon).

3. Lazy-Loading & Dynamic Sections

For infinite-scroll or lazy-loaded content, Web Speed uses the Agent Verification Loop:

- The agent can use evaluate() to scroll the page or trigger custom events

(dispatch('scroll')).

- It then re-calls read_page to capture the newly injected nodes, ensuring the "map"

stays updated with the dynamic state of the application.

Please let me know if you have any other questions.

@zaczuo I love how Grok Connectors aims to bring all our daily apps into one place - the tagline really resonates with me. Finding warm leads, like those who've upvoted similar integration tools, has been key for my own launches, and I'm curious to know if you've explored any partnerships with popular app marketplaces to expand your reach. How do you plan to distribute Grok Connectors to reach the widest possible audience, especially among power users who'd benefit most from this integration?

@jared_salois thankyouuuuuuuu

@ayeshabuilds sure

@kalashvasaniya why's the backlog of products so long that i can only launch in 8 weeks from now? not sure if this is going to work out. in the next 8 weeks i might have already forgotten about scrolllaunch again.

@thamibenjelloun thanks Thami - this is definitely what we hear from customers too!

@thamibenjelloun I was shocked to see the state of play with Action plans. It takes 4months to plan them and then no follow-through 🙈

@anitta_krishan me too!

@rivra_dev thank you! It's a great question. As employees have their conversation, the AI strips away anything personally identifiable in real time. Employees can even see what will get shared before it gets shared.

@hritvik_gupta1 that is a useful workflow. I have yet to encounter this issue, but how autonomous Agents are becoming, I can see it being catastrophic for any team actually exposing their confidential data unintentionally.

@hritvik_gupta1 hritvik, how does the 'human approval' gate work in the middle of an agent's loop? does it pause the execution and ping a slack channel, or is it more of a 'pre-approval' for certain document categories? definitely i'll check

@hritvik_gupta1 I'm really impressed by Suprbox's focus on securing enterprise data storage with AI agents - the idea of a "box" for this purpose is really intriguing. What I'd love to know is how they plan to distribute this solution to large enterprises, given the complex security protocols in place. Finding warm leads who have already shown interest in similar data security products has been key for my own launches, and I'm curious if Suprbox is leveraging a similar approach, especially with its unique "box" concept.

@vrijraj Thanks, hope you'll like the product.

@furqan_kidwai  @sarfraz_hussayn_07 I love the idea of using AI agents for FinOps workflows, the "Computer-Use" part of your tagline really caught my attention. Finding warm leads who have already shown interest in similar products has been key for my own launches, I'm curious to know how you plan to reach the right audience with Plouton AI. What's your strategy for getting in front of FinOps teams who could benefit from this type of automation?

@bengeekly hey there that's a good question. During every run that we have, basically a workflow, we record everything during that workflow, and then we sanitize the recording for any sensitive information. And after each workflow the video recording for each step is available for future reviews

@ghking I love the idea of tracking bots and AI agents crawling your website - the phrase "Track the bots" really stood out to me. For my own launches, finding warm leads who have already shown interest in similar products has been key, I'm curious to know how you plan to reach potential customers who might not even know they need a product like Known Agents. What's your strategy for getting in front of website owners who are likely to be concerned about bots and AI agents impacting their site?

@francesco2689 thank you! Right now, it’s a mix of all three.

Every website now needs basic visibility into AI agents and LLM referrals, which are becoming a new category of traffic source and distribution channel, similar to search or social.

What you do with that information depends on your industry. For example, publishers and content creators can use these insights to control access with robots.txt and firewall rules. E-commerce companies can see where shopping agents are getting stuck before completing a purchase, then optimize their UI and checkout flows to improve conversion.

@pdbthefifth Thanks!

Agreed, measuring and optimizing your content for LLM referrals from AI chat platforms (GEO, AEO, AIO) is becoming just as important as social and search (SEO) these days.

It's crazy how many people and businesses aren't looking into it at all, or don't even know that they should.

@david_pimentel Totally, there's so much more diversity within the bot ecosystem that people don't realize.

We're tracking around ~3,000 bots across 17 categories (e.g. AI Assistants, AI Coding Agents, AI Data Scrapers, Search Engine Crawlers, SEO Crawlers, etc.)

They all behave in different ways, and are interested in different kinds of content. It's really interesting to see the patterns.

@kylevenn Thanks Kyle! Agreed, we see an extremely clear trend in the data. More and more traffic is shifting away from humans and toward agents every day, and it looks like the ratio will finally flip in the next few months. Agents will be the primary user of the internet (the "agentic web").

@tyler_farley1 Exactly, basically optimizing "Agent Experience" (AX) rather than just "User Experience" (UX).

Known Agents does exactly that. For example, you can replay individual agent sessions to see exactly what path they took navigating trough your website, including where they dropped off. You can use that information to adjust that page to be more agent-friendly (e.g. maybe there are hidden elements, problematic asynchronous loads, or unclear copy that need to be adjusted).

@mohammedcarim I love the idea of having an AI Growth PM on call 24/7 - the "on call" part of your tagline really resonates with me. For my own launches, finding warm leads who have already shown interest in similar products has been key, I'm curious to know how you plan to reach potential customers who would benefit from onBeacon's unique AI-powered growth management. What's your strategy for distributing onBeacon to high-growth teams that could use an extra hand in optimizing their workflows?

@jared_salois Exactly right! The principles are weighted by context - product category, business goal, and the specific flow being analyzed. A checkout flow prioritizes principles around friction reduction and trust signals. An onboarding flow leans more on Aha Moment acceleration and habit formation. The more context we have about your product and users, the more precisely the weights are applied. It's the core of what makes onBeacon different from a generic checklist.

@thamibenjelloun Great question! We provide both Quick Wins and Strategic Recommendations so you can choose what to tackle first based on your bandwidth. Each finding is prioritized by impact on activation and retention, to help make the product decision easier.

@shumkov_code I love the idea of real-time AI dubbing for YouTube videos, it's a game changer for creators looking to reach a global audience. The "any YouTube video" part of your tagline really caught my attention, I'm curious to know how you plan to distribute Yeta AI to the millions of YouTubers out there. Finding warm leads, like those who have upvoted similar video editing tools, has been key for my own launches, so I'm eager to hear about your strategy to get Yeta AI in front of the right people.

@lakshminath_dondeti Thank you! Yes, unfortunately, most languages ​​on YouTube are not available for AI translation, and manual dubbing is expensive these days.

@lakshminath_dondeti We'll be glad if you use our service =) a free translation will allow you to translate a 15-20 minute video.

@samir_asadov Thank you! How was the service in short?

@rivra_dev Thank you! Yes, that's our advantage. We try to process the stream while the user is watching the video, sending data to the buffer in 2-minute chunks.