PH热榜 | 2026-07-22

@mcarmonas Congrats Martí 👏

The “when to speak and how to speak” layer is underrated.

We’re doing something similar for content — teaching the AI your real voice so it doesn’t sound like every other tool.

Best of luck today!

@mcarmonas congrats Martí - wish you and the team all the success in the world.

@mcarmonas Congrats on the launch. In groups where people have mixed expectations, how does Humalike decide which social role to adopt, and can users teach or correct that behavior over time?

@james_anderson77 :))))) tysm James! Happy to chat a bit more in our Discord community https://discord.gg/7bZFjm9aHH

@artstavenka1 Thanks for the question! 🫶

@artstavenka1Hey Art! These are some sharp insights you've got here. I'd say it's way harder to make agents biased toward silence, false positives are much harder to get rid of than false negatives, and they make the agent super annoying.

I'm here if you have anymore questions :))

@noctis06 Hey Noctis, these parts live on Humalike side. Both memory and classifier are on our side for few reasons:
1. ease of integration
2. easy way to ship improvements
3. the Hermes plugin uses Humalike APIs that are transferable from product to product. That means if you ever wanted to create your own agent you can easily use Humalike APIs and get similar behavior as Hermes x Humalike

Cost per turn is low from what we tested, when you sign up you get 10.000 free credits which should be enough for months of normal usage for hermes agent.

Let me know if you are concerned about something else specifically:))

@franz_brionesFor now, the underlying memory doesn't prevent it. We want the behavioral layer to be able to correctly assess what information should be shared and what shouldn't :)) It's, of course, a very hard problem and we don't claim to have an absolute solution.

@franz_briones Tysm for the support Franz!

@feride178675 Yep, exactly! That's what we mean by behavioral layer, and turn-taking API is acutally one of the 7 APIs we have available, although it's not tailor-made for voice. If you have use-case for voice where you need humanlike turn-taking, let's connect and chat:))

@feride178675 :)))))

@kartikmalik 🫶🫶

@kartikmalik Thanks Kartik! The optimization is already in how the turn-taking component works: a tiny "should I reply?" check runs on every message, and the full pipeline fires only when the agent actually has something to say!

@kartikmalik Appreciate it!

@vanmurten_eth Alexey! You're right, this problem is super hard. We handle it like a real human would, which means that as a new message comes in, the agent looks at the whole conversation and decides whether it should reply to any message from the conversation, taking the new message into account as context.

I am happy to answer any other questions you might have :))

@vanmurten_eth Thanks for the supp Alexey!

@vanmurten_eth Agree!

@hamza_afzal_butt tysm! Social skills & proactiveness!

@mateusz_jacniacki Had the same thought recently , our Ai agents can solve complex tasks but still struggle with basic human interctions . Love seeing someone tackle this problem head on . Best of luck with the laucnh.

@tarqiya_forgah Indeed it does adapt! We continuously update its understanding of the group through components like Norms, Social Memory, Theory of Mind, and Social Signals.

That lets the agent pick up jokes, understand what matters to different people and align with the local behavior.

@nayan_joshi Thanks! Yes! Talkativeness is part of the agent's personality, and each workspace/group runs its own, so the same agent can be all business in one room and playful in another.

And even without touching anything, thanks to social learning API, it reads the room and matches each group's rhythm on its own: quiet team, quieter agent.

@nayan_joshi tysm!

@jiteshghanchi Hahah, actually good that you ask, we should clarify.
We add whole new layer for turn-taking: decide when to speak vs stay stilent, that works well in group chats. We change how hermes acts when he is interrupted. We change the way he responds (short natural burst messages instead of long report-like messages). This is engineering work, not just a prompt.

We add Social Memory -> another layer of memory focused on people, their preferences, humor and opinions.

We add social learning that fires every few messages -> Hermes picks up new jokes, style and norms without you having to touch soul[.]md at all. It happens automatically many times during one chat.

Annnddd yes, we also improve your Soul based on our experience building 4 different humanlike agent products:))

You should give it a try, the jump you can make with Soul alone is 1.5x, with everything we got it's 10x

@jiteshghanchi 👀👀👀

@talhakhalidmtk One memory for all of your groups, platforms (discord, telegram, slack, whatsapp...) and threads. Give it a try and push it to the limit

@yaroslav_stelmakh Hermes is the definition of auto-improving agent, it has memory and learns new skills. Humalike plugin also uses this information to adjust behavior, and even makes it stronger thanks to Social Learning API used under the hood.

@yaroslav_stelmakh tysm!

@savazverjtjn :)))) That's great to hear!

@alex_watson2110 100%.. it's unusable by default. Give our plugin a try :))

@alex_watson2110 Thanks for the comment Alex! I'm here if you have anymore questions

@john_michael31 Hey, yes! We have an audit page where you can paste transcript of any agent (powered by Humalike or not) and you will have detailed analysis of how it performs.

We also have CLI for it if you want to run this analysis on recurring basis e.g. once per week!

@john_michael31 :))) https://humalike.ai/audit

@reda_roqai_chaoui Hahaha that's a good one! It depends a lot...
We built a AI Community Manager in the past that, if it was properly guided (through channels) and with a lot of constraints (behavior), the hardest part was how to make it human (infinite issues). Now, if you are building something with a lot of constraints and it's against product nature (having constraints is bad), making it less eager to participate is so hard.

@galdayan Hey Gal, good question! Today: "no", guessing two accounts are the same human is risky (hard to know who is who across platforms). But, if you build with our APIs and "tell us" (mark) ids/person, memory unifies across platforms :))

@omri_ben_shoham1 Hey Omri! Social intelligence is a big statement and we are aware of it. We could argue there is no "good or bad" when judging behavior, so it's really hard to measure. As of today, we are mesuring it "vibes-based", and also working on benchmarks such as https://arxiv.org/abs/2606.14600. We (& all devs/researchers) have a long way to go on delivering proper social intelligence, but we love the problem and we are building/doing research in that direction!

@terminal_candy Hey Peter!! Totally... we had the same problem. We realized how big of a problem this was when we were building an AI Community Manager in the past. Making an AI moderate, do support and have genuine conversations with a group of people is really really hard.
About groups norms, we have an API called Norms that exists just to solve that problem, + combining it with other APIs such as social intelligence and theory of mind, we are able to make agents adapt really well so far!

@dipankar_sarkar We've tried "everything" and so far the best way to approach this is re-running the decision after an interruption. There are ways to change this and it's valid if the community or chat is really active. Happy to go deep into it and share our experience :))

@waqas_baloch4 Tysm!!

@dipankar_sarkar Hey, I think these are two separate things:
1. actual latency for making a decision
2. "group has moved on" problem

We solve 2 really well by handling interruptions and making sure agent doesn't respond to old messages. About 1, yes, it adds latency, and it's not perfect. In our testing it's not a deal breaker in chat, LLMs are fast enough (compared to humans that acutally have to type each message). I encourage you to give it a try and see how you like it, we would love your feedback!

@dake_zhang1 Dake! You can build a Discord Bot with Humalike APIs in 10min. I have an old Discord community were I sold software (with thousands of users) and it runs completely in autopilot with a bot that's powered by Humalike :))

@gilad_tsehori Hey, humalike APIs are easy to build with. You can connect any kind of agent to Humalike. We don't have out-of-the-box integrations with Eve or OpenClaw though, let us know your use and let's chat!

@gilad_tsehori Not yet, Hermes is first integration for now. If people find value on Hermes x Humalike, really soon it will be on Eve or OpenClaw

@adam_lab Amazing !!

I absolutely love it. So excited to be part of this journey.

Migma has just revolutionized email marketing.

@adam_lab This is really huge!! Been watching Adam and Liam build this for months and the Zinn markup piece alone is a game changer, finally an email tool that doesn't break the second it hits Outlook. Compatibility + personalization + actual localization in one place? That's the SaaS email marketing has been missing.

@adam_lab The future of email marketing is actually here!! Seeing it on PH today feels surreal. Thank you all so much for the early support... genuinely means everything to us right now.

@priya_kushwaha1 Yep, compiled HTML, absolutely. Raw Zinn markup, not at the moment.

You get clean, email-ready HTML with merge variables already in the native syntax for Klaviyo, Mailchimp, HubSpot, Brevo, or Omnisend, so you can drop it straight in without having to rewire personalization.

You can push it through the native connectors or pull it via MCP or a webhook.

And the best part is that the HTML is built to render properly across Gmail, Outlook, Apple Mail, dark mode, mobile, and even older Outlook versions, so you know it’ll look right before you send.

Would genuinely love to hear your feedback once you’ve tried it 🙌

@1mirul Thanks so much! Cutting context switching was a big part of the design, glad it comes through.

@aditya_harish_2002 You’re spot on, email HTML is still surprisingly unforgiving.

Zinn handles the compilation side, but Migma also checks the campaign before send: real inbox and device previews, dark mode behavior, Outlook and Gmail quirks, clipping risk, broken links, and compliance essentials like unsubscribe and sender details.

So it’s not just “generate and hope.” You can review the actual output, catch issues early, and only send once everything looks right.

Would love for you to try it with one of your tougher templates and tell us where it breaks 🙌

@aidan_codefox That’s exactly what our Zinn engine is built to solve.

It goes beyond conservative table markup. It handles tricky cases like dark mode color inversion, especially in Gmail on iOS and Android, and you can also run real tests across real devices in Migma before sending to make sure everything renders correctly.

Really appreciate you bringing this up, the render matrix is one of the hardest parts of email, and it’s something we’ve spent a lot of time on.

Give it a try and put it through its paces. I’d genuinely love to hear what you think 🙌

@nico_mandera You keep full control. Migma gets everything ready, but a human approves it before it goes out.

Once approved, you can send it right away or schedule it, and Migma will handle the send automatically at the time you choose.

You can also review, comment, edit, or pause anything along the way. Migma just takes care of the busywork in between 🙏

@monir_ Appreciate that 🙏
It's actually the first layer we solved early on, so marketers spend time driving revenue instead of fixing things they shouldn't have to worry about.

Try Migma for free today.

@levi_mitchell1 Fair question.
Zinn's part of it, but the bigger piece is that Klaviyo and HubSpot bolted AI onto tools built for a human to run. Migma was built agent first, so it plugs straight into your own project through MCP and can handle your campaigns end to end, not just draft copy for you to finish but the entire workflow.

Come try a full cycle and see the difference.

@owen_parker4 Good question, small edits are grouped, so every tiny change doesn’t burn a separate credit.

You can also use the visual editor for free, which makes it easy to tweak and iterate without eating into your quota.

Really appreciate you flagging this, and would love to hear how it feels once you’ve tried it 🙌

@hannesh Yes exactly!

From Slack you can ask Migma what to send next, check the dashboard for results, or hand it a Figma frame and get back a ready email.

Come give it a try

@dipankar_sarkar The model writes Zinn directly instead of HTML, that's what keeps it fast and consistent across clients.

Come try it see how its super fast

@yahia_bakour3 yoo, please watch your APIs, we may burn your servers.

@yahia_bakour3 Yahiaaaa 🤗

@greggblanchard Migma <3 SendView thanks a lot for your support.

@greggblanchard Thanks so much! Means a lot coming from someone who gets both sides of it.

Come take it for a spin.

@philip_sorensen Thanks Philip! Let’s keep the big ones uncomfortable 😄

@yiitqx9x Our engine already renders every email to match across clients properly, so the base is solid before anything else kicks in.
On top of that, Preflight lets you preview it on real devices and clients before you approve, so you catch anything before it ships.

Try it here for free: https://migma.ai/email-html-spam-checker

@nihaln20560 Love this, and good news, we already have it 🙌 Preflight shows client previews (Gmail, Outlook, Apple Mail, dark mode, and more) before you approve, so you catch any Outlook weirdness before it goes out, not after.

Come check it out for free.

@abdurrahman_fakhrul Totally fair pushback.

Every send feeds data back in immediately, opens, clicks, what converted, so it's not waiting on a big batch to update. We don't have an exact "X sends" number pinned down, but people usually start noticing sharper segmentation and copy within their first few campaigns as it locks into what your audience responds to.

@glebarios Thanks so much, this means a lot 🙏

Brand tone comes from what you feed it (your assets, guidelines, past campaigns) and it keeps refining that as you approve, edit, or skip sends, so the more you use it the closer it tracks how you actually write and what you're okay shipping.

Performance also feeds straight back in: opens, clicks, what worked, what didn't, all shaping the next campaign automatically.

Come try a few campaigns and you'll feel it get sharper send over send 📬

@shahriardgm  Great question 🙌

When you connect your own domain, Migma handles setup and warmup for you, so it ramps up gradually and lands in the inbox instead of spam, meeting all the checks that actually help conversion along the way.

If you don't have a domain yet, you can send straight from Migma with a shared address, no setup needed. Or you can buy a new domain right inside Migma at an affordable price.

Come connect yours and try a send, would love to hear how it lands for you 📬

@omri_ben_shoham1 You're right, when someone gets 3-4 emails before buying, giving one email the credit is guesswork. So we don't force it onto a single email.

We track which emails a person actually clicked, and spread the credit across those, leaning toward the ones they engaged with most. Opens we mostly ignore since Apple Mail fakes a lot of them.

The part we really trust is the pattern across lots of sends, not one person's path. If the day-3 email with one subject line keeps showing up before people buy, and another version doesn't, that tells us something real even when any single journey is messy.

That's the math no one has time to do by hand.

Best way to judge it is to see it live. Would love for you to try it.

@danielboardman Thanks, really appreciate that 🙌

Your clients can keep Zoho, GoHighLevel, or their current CRM as the core system. Contacts are imported or synced into Migma through native integrations, connected ESPs, or API/webhooks, depending on the setup.

So there’s no need to move the rest of their operations. Migma handles the campaign workflow, while the CRM stays the main source of truth.

Would love for you to try it with one of your client setups and tell us how the workflow feels.

@foobar_beer Absolutely, that’s a big part of how we think about the product.

Migma helps on three fronts: content and compliance checks before send, deliverability and warm-up guidance, and reputation monitoring through your connected ESP.

The goal is to help you avoid the common issues that hurt sender reputation, not just generate the email and leave the rest to chance.

Would love to hear what your current setup looks like when you get a chance to try it 🙌

@clemente_lopez1 No. Volume makes the loop faster, but it is not required.

For a small, high-value list, the useful signals start before opens or purchases: what you approve, edit, reject, who you choose to send to, and when you decide not to send.

Migma should become more conservative in that setting, not more autonomous. It prepares the campaign, learns your judgment, and you keep approval before anything goes out.

The goal is not more sends.

It is one email a month that sounds like you, lands at the right moment, and does not burn a relationship.

@clemente_lopez1 You've nailed the real constraint here. High-value B2B lists are unforgiving as one bad send to a spam trap or invalid address tanks your sender reputation instantly, and suddenly Migma's learning loop breaks because mailbox providers are already filtering you.

Before Migma learns what works, you need the list itself to be trusted. That's exactly where we built Mailthentic. We validate every address, flag risky patterns (typos, role-based, honeypots), and remove the deadweight so Migma's AI gets clean signal to learn from.

For your healthcare B2B scenario: clean list first → Migma learns on engaged buyers → revenue compounds. Skip the cleanup and even perfect campaigns get junked.

Happy to chat about integrating list verification into your workflow if you're interested.

@terminal_candy Outlook is exactly the client we built hardest for 🙌 Zinn covers the old desktop versions too, not just the modern web ones, down to Outlook 2003.

Come put it through its paces.

@ben_kahan Really appreciate that 🙏
Timing is one of those things that's easy to get wrong, so glad it's landing right.

Come take it for a spin

@carlos_mendez16 Yes! Connect a new domain and Migma warms it up automatically, so you ramp up sending without hurting your reputation.

Come try it for free!

@dipankar_sarkar Great question! The model writes Zinn directly, not plain HTML. That's a big part of why generation is so fast and stays consistent across clients.

@dipankar_sarkar It took us years of engineering to reach this point.

@derrickshowers Thanks so much! It's not just one signal, we look at a mix of engagement data, opens, clicks, heatmaps, and how people actually interact with the email, not just a single number.

Come give it a try for free.

@ringo_td5 Love how you put that 🙏 That's exactly the shift we're going for, Migma doesn't wait around for a brief.

Come see what it drafts for you

@shiying_zhang1 That's awesome - being able to have entities/identities being persistent across shots is very cool, are you able to use those identities across different projects? (thinking you can then run a consistent 'character' for all brand media).

@shiying_zhang1 how Buzzy handles creative consistency over longer projects. When users are building a multi-scene video or campaign asset, does the AI maintain context around brand guidelines, characters, visual style, and storytelling direction across iterations? Also, are there plans to introduce team collaboration features for creative teams and marketing departments?

@shiying_zhang1 Curious, how do you handle governance for AI-generated applications? For example, can teams enforce security, compliance, and architecture standards across every app built on Buzzy?

@artstavenka1 Yes — you can switch the underlying model from shot to shot while keeping the same shared character and references. Some variation can still depend on the model, but Buzzy gives you a consistent project context and lets you refine any drift without rebuilding everything from scratch.

@aix_pan Exactly. Buzzy lets you shape the story scene by scene, revise individual shots, and adjust pacing and mood without starting over.

@boyso Closer to a creative studio you work inside. You organize your story, characters, references, and scenes on the canvas, then use conversation to revise specific parts—not just send prompts and wait.

@li_huang1 Really appreciate that

@franz_briones Hi Franz, this is a very good question. For vocal consistency, we do have audio node on our canvas, where user can generate their specific character voice using the audio node. Then for each video clip, they can reference that audio node so seedance 2 will keep the reference to that voice and keep the voice consistent across all video clips.

We don't use lip sync a lot, since the results seems not quite good but using the seedance 2 directly by referencing that audio node will really help

@niallcleaver Great question! You can establish your style through references, characters, lighting, and visual direction, then reuse them across scenes. The more clearly you define those elements, the faster the workflow becomes consistent.

@mingyouagi That’s a great use case.

@andrewstone11 Great catch! Buzzy keeps characters, locations, and references persistent across scenes, so consistency can extend well beyond short 3-shot clips. We’re continuing to push it further for longer sequences.

@fayann It leans more toward a directing workspace than a pure video generator. You can generate footage, but the real focus is organizing and refining stories, characters, scenes, lighting, and shots with continuity.

@aidan_codefox Exactly — Buzzy treats characters, objects, and locations as persistent entities, while shot-level edits can stay local. We’re also exploring better controls for propagating changes across a sequence. Great question!

@kaining_luo You nailed it. The goal is to keep the creative decisions with you while Buzzy handles the execution—not turn filmmaking into prompt engineering.

@sulemna_ola Our neutral enforcement engine across models and agentic systems enables us to enforce the same rules throughout the stack. We want to enhance how you use the tools you love, not replace them.

@sulemna_ola Yes, and we are adding support for more tools every day! Thank you!

@nancy_philip Exactly, we have seen our users want to customize the rules that adjust to their agentic coding style. We allow them to do so; at scale, this helps build trust, and trust allows them to delegate more work to their coding agents.

@nancy_philip Exactly, only a deterministic, neutral layer can enforce this.

@peter_victor That's exactly the philosophy behind Kastra. We believe authorization should sit directly in the execution path, where every tool call, shell command, API request, and file operation can be evaluated before it executes rather than remediated afterward.

@ramish_saje Yes, the prompt engineering rules/policies are often probabilistic approaches that can't be guaranteed to work 100% of the time. There is a margin of error that some engineers and enterprises can't take the risk of "trusting". That is why we built our engine fully deterministic, so we can build these rules for every custom angle but make sure the highest-risk actions are avoided before they happen. What exists in the market is mostly post-action observability and monitoring, which is insufficient for autonomous AI.

@steven_granata Great question. We evaluate every execution independently, not just the initial request.

If an authorized action triggers additional tool calls, each downstream action is intercepted and evaluated against the same policy engine before it executes. Authorization doesn't "carry over" simply because the parent action was allowed.

@grayson_carter3 Yes, this is a very common problem. We've heard similar stories from a lot of developers over the past few months. As agents become more autonomous, trusting them isn't enough; you also need deterministic guardrails around what they're allowed to do. That's the gap we set out to solve with Kastra.

@carlosjimenez1 Really like that Kastra focuses on governing AI agents before they take action rather than reacting afterward. Having a single policy layer across different AI tools feels like a practical way to improve security and control. Good luck with the launch!

@carlosjimenez1 how Kastra handles dynamic permissions , can policies adapt based on an agent’s context, user intent, or risk level in real time? Also, are there plans to provide analytics around blocked actions and security insights to help teams improve their agent workflows over time?

@carlosjimenez1 How does Kastra balance strict policy enforcement with developer experience? For example, how do teams debug or fine-tune denied actions without slowing down agent development?

@thomas_jack3 Very accurate! We learned this by testing the product with some of the top enterprises pushing AI products into production. We realized autonomous AI products required a new infra layer and we built Kastra to solve the trust problem in a scalable way.

@galdayan This is a great point. We learned from enterprise conversations that policies needed to be tested per environment for high-frequency authorizations in order to be trusted by large companies that could not have a single point of failure.

So we enabled these fail-open and fail-closed features so every integration can be tested and evaluated before launching to production to make sure the risk of the integration was minimal. Think of it as sandboxing policies in a custom environment: one mode logs every decision without blocking, and the other one logs and blocks them. This can be switched on the dashboard at any time once the customer is ready. The interception and enforcement engine works just the same with every authorization.

@1mirul exactly! The primary goal is to deterministically stop things before they happen. The monitoring and logs are a natural byproduct, since we're already intercepting every request anyway.

@1mirul Thanks! That's exactly how we think about it. Monitoring is valuable, but once an action has already happened, you're often in incident response mode. We wanted to give developers a deterministic decision point before execution, so they can safely delegate more work to AI without giving up control.

@lisa_shmulyan thank you for the support Lisa! 🙏

@lisa_shmulyan Thank you for the support, Lisa!

@baharyakupbcr2 Awesome Bahar, glad you had a good experience! Keeping the AI flow fast was a concern for us since day one. Every decision was made around adding this security layer without hurting performance.

Thank you@odeth_negapatan1, that's exactly the gap we set out to close!

@charlos_brat Exactly! And the nicest part is it isn't either/or. Every decision Kastra makes before an action runs is written to a tamper-evident, per-tenant hash-chained decision log, so the "audit after the fact" is just the other face of governing before it. And because it's chained, you can prove nothing was altered or dropped. There's a chain-verification API an auditor runs, not a log file you take on faith.

@paula_jimenez4 Kastra is great for new builders learning how to code; it teaches them the risks and helps them understand the agentic coding workloads better by being able to evaluate all the actions, risks, and decisions at runtime.

@carlos_campos93 This is great, thank you. We're happy we can bring value to you!

@churds Exactly, Richard, this gives you a baseline of policies that adjust to your coding behavior first. Then, once you have this baseline, you can build new daily policies on top of them to continue reducing risks you learn along the way. Some Recon scans from our customers show many important high-risk actions they were not aware of; some thought they were protected with their existing frameworks, and the reality was different.

@churds Happy Recon could help, Richard!

@monir_ We hope you enjoy it! Thank you for the support! 🙏

@terminal_candy very granular. Kastra sits in front of the action (a pre-tool hook for Claude Code / Codex / Cursor, or the LLM proxy), so every tool call is evaluated before it executes. A rule can target:

• A specific tool: exact name, a list of tools, or a regex (e.g. only Bash, or every mcp__* tool).

• The tool's arguments: substring, multi-substring, or regex conditions over the tool input (e.g. block Bash when the command contains rm -rf or git push --force; block Write when the file path matches .env). On the proxy path, arguments are flattened per field (output.tool_call.arguments.<key>), so you can match one named argument in isolation.

• The context around the call: working directory, git repo/branch/dirty state, session, OS, agent permission mode, environment (dev/prod), model, principal/agent identity, data classification.

• Content: built-in scanners (secrets, PII) can run over the tool input or model output with confidence/count thresholds.

And "no" isn't the only answer. Each rule chooses its effect: hard deny, hold (pause the agent and page a human to approve, with a timeout that fails open or closed, your choice), monitor (allow but flag), redact, rate-limit, or spend-cap.

@anic_dev congrats on the launch!

@anic_dev  Congrats on the launch. You guys built a great product. Happy user here!!

@anic_dev Curious about how Box handles agent memory and environment persistence ,can agents maintain context, learn workflows over time, and reuse previous setups across different tasks? Also, are there plans to add collaboration features where multiple agents can work together on complex workflows?

@thys_beesman we hit such low price because we designed the whole system for cost efficiency, using no dependencies and minimizing the operational costs. we have our own snapshotting system (beautiful tech built in-house), allowing you to easily stop/resume/fork your machine.

@thys_beesman Compute in European datacenters is just that cheap, its just hard to build around, we still make v good margins.

@luaroncrew The goat

@tessak22 box.ascii.dev/compare explains well how we're positioned
tldr: if all you need is 4vCPU 8GB ram sandboxes we're 9-10x cheaper with comparable feature set

@aditya_harish_2002 no it's stable, even at the thousands box per user scale

@meta_nkt thank you Nikita!!

@vgrichina lfg!

@ogandreakiro X anic_dev

@mnevvertumazji you already can! see the templates section of docs.ascii.dev

@hediyedilli it is totally already built in!

@arth_tyagi Hope it's going well! Lmk if I can help in any way :)

@kartikskabadi Thank you so much Kartik! It's a pleasure to help you

@aidan_codefox So many hard problems to solve in that space for so many different usecase.

We catter best to long running agent whose data is precious and never to be lost

@abhishek_iyer The interview-first step is the interesting bet. Most AI SEO tools I've tried fail because they never learn what the business actually sells, so they optimize for traffic nobody converts. What does the interview capture that a good brief wouldn't, and how do you keep it from drifting back to generic keyword output after a few runs?

@rohanrecommends  @abhishek_iyer Congrats on the launch! Really like that this is built around actual first-hand expertise instead of just cranking out generic AI content, that EEAT problem is real and most tools just ignore it.

Couple questions:

With Interview mode, do I need to already have a clear opinion going in, or does it help me figure out what I actually think as we go? For Deep Research, do I get to see/check the sources before they end up in the draft, or does it just fold them in automatically? Can I choose where the Approval Gates kick in (like after the outline vs. right before publish), or is that fixed? Good luck with the launch!

@abhishek_iyer  @dyuti We did not abandon ours, we changed what the model was allowed to do. Ours used to handle the mechanical parts too - quotes and dashes, stage tracking, SEO fields - and the quality was uneven. Once that moved into scripts and it was left with only the writing, the drafts got better and cost less. The generic tone was not the model. It was how much non-writing work we had given it.

@jiteshghanchi In a sea of AI Slop blogs - turns out human opinion is the most important missing piece!

@yeterezlb Yes - part of building this tool for ourselves (being the lazy people we are) meant that we wanted to remove all friction to posting - that includes opening a website / desktop session. The feeling of writing content pieces on the go is truly magical :)

@chloe_bennett Iteresting use case - like a good interviewer, it is designed to ask probing questions on a topic and will genuinely force you to think on a topic.

By default it asks only three questions which might not be enough to form a strong opinion on the topic. You can, however ask it to do a longer interview and it will oblige.

@sedat127428 Couple of thingsr

1. Your raw notes can verbatim uploaded in the Knowledge Base it will be used / quoted as a part of research and forming perspectives.

2. For the raw voice of the narration, at the moment we're only have the option to learn voice from a reference URL that is already published. Based on your feedback will consider adding adding an upload option for the brand voice reference as well.

@alparslansril Awesome - glad you found it useful :)

@abdurrahman_fakhrul Yes. All interviews go verbatim in a knowledge base. So not only does the content get reused.

Even the interview builds on top of the previous interviews so that you're not asked similar set of questions again and again. Instead you get to go deeper into the topic with every interview.

@aryan787544 Great question, and worth clarifying a little about the purpose of the interview. It's less about being an SEO diagnosis of your content, and more of a way to pull out your first-hand material, the opinion and numbers that make a post worth reading.

Research handles the diagnostic part separately. Keyword research and content calendars are based on search data from the audience, not from what you assume they search.

So if your stated problem is not the real bottleneck, the data usually surfaces that on its own.

@omri_ben_shoham1 The default is set to a short one, but it offers to go on if youre up for it - so it really does not have an upper limit on how long / deep the interview goes.

What genuinely surprised me is that how even a small 3 question back and forth can shape how an article turns out.

Another thing I'd like to point out is since all interviews go into the Knowledge Base there is continuity in the interviews - so over time the small interviews also add up to get really meaty.

@clemente_lopez1 

On volume: So search volume is a lagging, averaged signal. In a narrow B2B niche the queries that convert often show as zero in every tool because the tools round down anything under ~10/month. So no, the research doesn't rank topics by volume alone. The interview + your knowledge base surface the questions your actual buyers ask (which you know and no keyword tool does), and the keyword research is there to shape the piece around how those questions get phrased

Honestly, healthcare B2B specifically is a good stress test for us - esp. if you try it on one of those zero-volume posts, Would love to hear whether the interview pulled out the depth that would make the post useful and make it rank!

PS: "Competent and generic at once" is going on a wall somewhere

@aditya_harish_2002  Thanks - that's exactly the bet we made.

Keyword-first tools converge on the same SERP summary because they all start from the same inputs. The interview is the only input your competitors can't have.

On the GitHub connector: yes - we have a review gate that waits for your feedback (as configured). Also drafts land in your repo as a pull request, so your existing review flow is the approval gate. Edit in the PR, request changes, merge when ready. Nothing goes live until the merge. ACME.BOT's own approval gates still apply upstream (before the PR is even opened) if you want a check earlier in the pipeline

@varun_dhamija Glad you liked the interview mode. The interviews compound over time in your Knowledge Base. So as you keep using ACME.BOT to write more blogs the context will keep building.

@mitalee_rao Hi Mitalee - What custom stack are you on? If your custom blog is on Github / with markdown, we have a GitHub connector. You can try it from the connectors page.

@noctis06 

re. Storing interviews: Yes, all your interviews go inside a knowledge base. So any future documents can reference it and cite it.

re. Publishing: Right now we support Wordpress, Shopify and GitHub.

@reda_roqai_chaoui Yes, the Knowledge Base helps - every time we do an interview we end up going one level deeper. So the knowledge from the interviews builds up being a rich and deep repository of your opinions and takes over time. Based on that the later posts will end up going deeper into the takes as opposed to the initial ones.

@galdayan The motivation is to not disguise - it's actually to just iron out the awkward phrasing etc. The fact that it ends up beating AI detection is a side effect, not the explicit goal.

@carlos_mendez16 Not sure which one you mean - since there are a handful of products that go by the same name :)

What ACME.BOT is - proactive AI agent that sets your content schedule, pings you for your inputs when its writing, waits for your reviews / approvals and publishes. All from your phone. You end up publishing your own unique take ie. non-commodity content - not average of wikipedia

@maganuk The accountability question is the real one. "Accountability, judgment, and ownership still belong to people" isn't just a nice line, it's the actual gap most teams are ignoring while they rush agents into production.

Here's the layer I'd want to understand for client delivery work specifically: when we build an agent for a client, who's the principal it's acting on behalf of, the client's end user, or us as the vendor who built and deployed it? That distinction matters the moment something goes wrong and someone has to own it.

@suryansh_tiwari2 thank you so much. it always looks like a solved problem until you're actually in it 😄 really appreciate the support!

@hazy0 Good question, this is exactly what our API Access Policies are built for. Cedar runs at token issuance (the IssueAccessToken action), so it gates what the agent can get: which API, which scopes, which token settings.

 
Downscoping: yes, as a ceiling you author, default-deny, and forbid overrides permit. The agent is the principal, the user rides along as context.user, and requested scopes come in as context.requested_api_scopes, so a single permit can require that a real user is present, that the user is in an eligible group, and that requested scopes never exceed the ceiling you set. 

Mid-task revocation depends on token type. Reference (opaque) tokens are checked against server state on every call, so revocation is immediate, the next call fails. JWTs are self-contained and live until exp. For agents that need instant revocation: set AccessTokenType = Reference, keep lifetimes short, and optionally BindTokensToSession so ending the user's session kills the agent's tokens too. Policies are re-evaluated on every issuance and refresh either way, so pulling the agent's permit stops new tokens at the next refresh — only already-minted JWTs survive to expiry.

Happy to walk through your exact agent setup on a call.

@maurya_abhiranjan Revocation is checked live at validation time, before a client can get or use another token, not left until the token expires. You've got live OCSP for status, CRLs, and a local deny list to block a cert outright. How fast it actually takes effect comes down to the cache windows you control on the trust store, OCSP status is cached five minutes by default and CRLs fifteen, and you can tighten those toward near-instant. The full set of mTLS validation and revocation settings is laid out here if you want it, monocloud.com/features/mtls

@suyash_kr Not tied to a runtime, it's SPIFFE-based, so anything with a valid SVID works, whether it's a Kubernetes pod or a workload on a VM. If they share a trust domain one trust store covers both, and if they're separate domains it's one trust store each. The setup walkthrough is here if it helps, monocloud.com/docs/guides/workload-identity

@arduvey29 Thanks! A token never inherits permissions, it's decided fresh at every issuance under default-deny, and you can forbid a sensitive API from ever sharing a token with others, so a token can't quietly widen to reach something it shouldn't. Tokens issued over mTLS, including X.509 SVIDs, are certificate-bound, so a copy is useless without the matching cert. If you want to see how that's written, there's a full guide with example policies at monocloud.com/docs/guides/api-access-policy

@tarqiya_forgah Not very opinionated, it's standard OAuth and OIDC with drop-in SDKs, so you adopt it piece by piece rather than rewriting your app. On the Cedar part, to be precise, the authorization policies are evaluated at the moment MonoCloud issues the access token, so the authz layer and token issuance go together. The full value shows up when MonoCloud is in the token path for the APIs you want to govern. If you're thinking of running only the policy layer on top of a different auth provider, I'd love to get into your exact setup.

@yaroslav_stelmakh Good question, and it's a real gap most setups have. Every token request is audited with the acting principal, the trust store and certificate context for mTLS, and the policy evaluation itself, so you can see who acted and whether it was allowed. Human versus agent is built into the model rather than guessed, clients carry a type of either application or agent, and machine-to-machine requests carry no user in the request, so an agent action looks structurally different from a human one. The permissions side is the Cedar decision that gets logged with the request. The client-type and context details are here if you want them, monocloud.com/docs/guides/api-access-policy

@kervangamz80440 Thanks, that was a deliberate choice. Certificate-bound tokens make a stolen token useless without the key, and that shouldn't be something you only get once you're big enough for an enterprise tier. The free year for startups includes it, so early teams can build on cert-bound trust from the start instead of retrofitting it later.

@mateuszkonik Yes, the agent is treated as a separate identity. It doesn't reuse the user's token. The agent obtains its own token to act on behalf of the user, so agent activity is always distinguishable from the user acting directly. Cedar comes in at token issuance: each API (a resource client in MonoCloud) can have multiple Cedar policies attached, and whenever that API is requested  via the authorization or token endpoint, all of its policies are evaluated first. A token is issued only if every policy passes, so access to an API is gated by policy right at issuance. As for migrations, you can bring users over programmatically via our Create User endpoint (MonoCloud - Authentication Platform for Developers | SSO, Passkeys & Next.js - you can use user claims, private data and public data fields to capture all of the users properties from your current provider. Happy to dig into any of this further, and there's a lot more detail in the docs (https://www.monocloud.com/docs).
I'll be happy to walk you through the setup.

@thys_beesman You are right that it is already the wrong shape. A single service role key with full reach is where almost everyone starts, so you are in good company.
The second process is where it really starts to hurt. Once a billing job and an enrichment job are sharing one credential, a leak means you cannot even tell which one did what, and you end up rotating the key on both.

The way we think about it, each process should get its own scoped identity instead of everyone leaning on one key. You give that identity a policy for what it is allowed to do, so the enrichment worker can only enrich and the billing worker can only touch billing. If one of them is ever compromised, you revoke just that identity without taking the others down, and every action is logged against that specific agent instead of getting lost in generic DB logs.

I am curious, are these long-running services or short-lived jobs, and where do they run, somewhere like Kubernetes, Fly, or Railway? That is what will decide whether workload identity with SPIFFE or short-lived machine-to-machine tokens is the cleaner path for you.

@omri_ben_shoham1 We audit the identity layer, and it's fairly detailed, the principal that acted, the mTLS and trust store context, and the policy evaluation itself, including whether the decision was allow or deny and why, for example a revoked certificate. What it doesn't capture is the model's prompt or reasoning, and that belongs in your agent or observability layer. You join the two by the agent's identity to explain why it acted.

@dipankar_sarkar When there's no human, there's no user in the request. Machine-to-machine grants carry no user context, so the agent authenticates as its own principal, an agent client or a SPIFFE workload, not an anonymous session, and what it's allowed to do is set by policy on that identity. The grant-type and context detail is all written up here if you want it, monocloud.com/docs/guides/api-access-policy

@medal411 Sharp catch. Classic step-up does assume a human is there to re-verify, so re-prompting a fully autonomous agent for a passkey doesn't make sense. Two things cover the agent case instead. When a human should sign off, you use human-in-the-loop consent, pausing the agent before the sensitive action and requiring a fresh approval. When it's genuinely autonomous with no human, you don't step up at all, you gate the action with policy, a Cedar rule that decides whether that agent, with that scope, is even allowed to trigger the payment, rather than re-verifying someone who isn't there.

@krekeltronics Exactly this. The one all-powerful key is where almost everyone starts because it ships fastest, and it stays invisible right up until the second automated process has to share it. Scoped identity per agent plus revocation you can actually trigger is what makes delegating feel safe instead of just hoping. Well put.

@galdayan Fair question, and the right one to ask about anything as sticky as identity. There's no cliff. When the free year ends you move onto our standard published plans, not into an enterprise sales conversation, so it's a predictable, self-serve scale-up rather than a renegotiation. We kept the step up gradual on purpose, because a team that grew on us for a year and then churned over sticker shock would mean we got pricing wrong. If the jump ever looks steep for where you are, reach out before the year's up and we'll sort it out. The whole point of the free year is to take pricing off the table as a reason to ever leave something this core.

@andrew_lukas We've paid people to do exactly this by hand, and the hard part was never finding communities, it was reading which ones would actually welcome a brand versus quietly resent it. How do you tell an engaged community from one that turns on outside brands the moment you show up?

The filename being renamed is normal on many sites. Check the Network tab in DevTools during the upload—the response often includes the new file URL or ID. If it doesn't, the files are likely stored privately and not directly accessible.

@andrew_lukas big fan of yours! let's go gener8tor companies!

@priya_kushwaha1 Short links, mostly. We don't really need promo codes to get there. The link carries the attribution, so you get click through to conversion on the brand's side without asking a creator to remember a code or a customer to type one in.

The other half is that our creators are actually on Trovio with their accounts connected, so we can pull the post-side numbers straight from the platform instead of relying on screenshots or self-reported stats. So you get both ends... what the post did, and what it drove.

Thanks again for checking it out!

@tyler_bush Great question, and honestly it's one of the biggest problems in the space. A few layers to how we handle it. First, creators on Trovio connect their accounts directly, so everything we work from comes straight from the platform APIs and refreshes nightly. No screenshots, no self-reported media kits. Second, our matching leans on engagement quality and consistency over time rather than follower counts. Bought followers are pretty loud in the data: big reach numbers with engagement that never follows.

There's also a quieter filter built into the model itself. Every creator on Trovio is a paying subscriber actually running their business here, and bot farms don't pay a monthly subscription to manage a fake audience. And the final backstop is that the dashboard tracks conversions, not just reach. Bots don't buy things. If an audience isn't real, it shows up exactly where you're looking.

@olsoj029 Yeah, honestly that's the thing that bugged me most about this space. Creator attribution is usually either a vanity metric (views, engagement, "estimated reach") or a pile of UTM params that nobody sets up consistently and that get stripped the second someone copies a link.

We do it at the link layer instead. Every creator on a campaign gets their own short link... clean enough to say out loud or drop in a bio, with the attribution baked into the link itself rather than a query string trailing off the end.

Once you have that, the more interesting part opens up. You can see which creators are actually driving results, not just impressions, and that becomes real feedback for the brand... who to re-sign, who to go deeper with, who's worth building an actual relationship, etc.

And because creators tend to cluster into communities, once we know someone's performing in a given community we can point the brand at other creators in that same community and then measure the whole group against each other. That's the part I'm most excited about!!

Thanks for checking us out!

@steven_snider Thank you!! Totally fair question, and honestly it's why ads still look the way they do: big names are easier to find and easier to justify internally. But the conversion math points the other way. Based on industry benchmarks (HubSpot's Influencer Marketing Report + Influencer Marketing Hub's 2025 benchmarks), $50K on one macro creator gets you about 2.6M views and roughly 1,150 conversions. That same $50K spread across 10 smaller creators gets fewer views (about 1.9M) but roughly 4,700 conversions. Fewer eyeballs, about 4x the buyers, because people actually act on recommendations from creators they trust.

The reason brands haven't done this already is logistics. Finding, vetting, and managing 10 creators used to be way more work than booking one name. That's the part Trovio takes off your plate.

@sean_adams_pantano1 Thanks Sean!! Great question. We don't take a cut, and honestly that's the core of the whole model. The terms you set in your brief are exactly what the creator gets, no markup on either side. This allows us to run on a subscription model vs. only chasing 6 figure deals.

@shane_mueller Absolutely - you get ultimate say on who you decide to work with and the conversations you think match best to your brand!

@niallcleaver Great question. Since we have all of our creators connected to Trovio - and not just a scraped list, we actually keep up with each and every post and their engagement so we can see over time as niches, communities, and attitudes change and then change in real time with them, so the brands are never getting stale matches.

@doaniikrinu Thanks for checking us out!!

@jake_whitman Good question! A bit of both. You give us the starting point, basically what you sell and who it's for, and honestly even just your site gets us going. Then we do the research from there. The other side of Trovio is thousands of creators with their real accounts connected, so we've built a map of communities from their actual content and who engages with it. We place your brand into that map and surface where your customers are already hanging out, the creators those communities trust, and why each one fits.

The fun part is the matches you wouldn't have searched for. Your customers usually live in way more communities than your category suggests, and that's exactly what keyword search misses. Every match comes with the why in plain language, so you can gut-check it instead of trusting a black box.

@aditya_harish_2002 Really thoughtful question, and the honest ranked answer is: mostly community and content signals today, with conversion patterns as the layer that compounds over time.

Concretely, each "why this fits" is built from where the creator's audience actually lives (the communities they're part of and who actually engages with them) plus the creator's own content: what they genuinely make and talk about, which is how we infer whether they'd actually use and need what you sell rather than whether they tagged themselves in your category. We deliberately show those signals in plain language instead of one opaque score, because a surprising match without a legible why just reads as broken matching.

On past conversion patterns: that's the part that gets stronger as deals run through the platform, since every brief has conversion tracking attached. I'd rather be straight that we're early there than pretend we have years of conversion history. The nice property is it compounds, every campaign that runs makes the next match rationale sharper.

@betsy_seus Good question. There are two ingredients. On the creator side, thousands of creators have connected their actual accounts, so we build the community map from their real content and who engages with it, not from labels people picked in a dropdown. That's what surfaces communities that don't match any single niche, like comfy-clothes people pulling from gamers, nurses, and new parents all at once.

On the brand side, you tell us about your product and who buys it, and we place your brand into that same map. So the matching happens in one shared space (communities), rather than trying to translate a keyword into a creator category. And every match shows the reasoning in plain language, so you can sanity check it rather than trusting a black box

@wesc Thank you! This is an awesome question.

The matching itself already runs at the community level, and when you tell us about your brand we usually surface several distinct communities, because almost no brand maps to just one buyer group. So multi-segment discovery is native to how it works. For briefs, my honest take today is that one clear buyer group per brief performs better. Terms, creative direction, and what a good deliverable looks like usually differ by segment anyway, so a few focused briefs beat one broad one that averages across audiences. But letting brands define named community profiles and track them side by side inside one campaign is a really good idea. Noting it for the roadmap.

@chase_mine Good question! The honest answer is AI does the finding, you do the deciding. Where the AI earns its keep is the discovery problem: mapping which communities your customers actually live in and which creators those communities trust. That's a many-to-many matching problem that a search bar (or a person with a spreadsheet) genuinely can't do at scale.

But nobody represents your brand without you choosing them. Every match comes with the reason it fits in plain language, and you review the matches, decide who to invite, set the terms in your brief, and approve the final deal. So the AI narrows the field from millions of creators to the handful worth your time, and the actual call is always yours. If a match ever feels wrong and the "why" doesn't make sense at a glance, that's something we'd genuinely want to hear about.

@ihabib Thanks for the Question. We helped 3 creators just last week get their first ever deals. Honestly that's kind of the heart of the whole thing. The creator side of Trovio is built for the 99% who don't have representation, and a lot of them have never done a brand deal before. They have real audiences and real trust, they've just never had a way in, because the agency model only pencils out for the top 1% and everyone else gets ignored. Those are exactly the people who show up in your matches, and they're often the highest-trust voices you can get, precisely because their audience isn't used to seeing them do ads.

On surfacing unknown communities: the map is built from creators' actual content and who genuinely engages with it, not from categories anyone picked. Communities are many-to-many, one community pulls from a dozen niches, so when we place your brand in that map, you see communities you'd never have thought to search for. That's the whole point really. If you already knew to search for it, you didn't need us. Every match comes with the why in plain language so the surprising ones make sense at a glance.

@hazy0 Really appreciate this one, and you clearly get the thesis. Honest answer on the platform question: today the matching is built on creators who connect their accounts directly, with Instagram and TikTok first-class and YouTube rolling out now. Discord and Telegram native communities aren't in the graph yet, but our whole approach is meeting creators where they are, so any platform where real communities live is on our radar. Web3 is honestly a great example of trust living in closed spaces rather than public feeds.

The connect-their-account part is also the answer to your bot question. We don't scrape public profiles and guess. Creators link their real accounts, so we see true engagement straight from the platform, not follower counts, and accounts flooded with bots are pretty loud in that data: big reach, engagement that never follows. That verification layer is exactly what we'd bring to any new platform we add, closed communities included, because putting a brief and budget behind an unverified community is the thing we're trying to completely eliminate.

@cemil1216871 Thanks so much!! We really appreciate it!

@sarah_showers Thank you!! And definitely multiple. Honestly spreading the budget is kind of the whole thesis. When you post a brief we surface a set of matched creators, and you decide how many to work with, whether that's one or ten. Terms are per creator, so you can mix bigger and smaller partnerships inside the same budget, and everything runs from one place so ten conversations doesn't mean ten times the work.

The reason we push this way: by industry benchmark math, the same spend spread across a group of well matched smaller creators drives about 4x the conversions of putting it all on one big name. Fewer total views, way more buyers. A portfolio also derisks things, you learn which communities convert for you and put the next dollar there instead of betting everything on one bet working out.

@abdurrahman_fakhrul Not Reddit or Discord, actually. The communities we care about live around the creators themselves, so mainly TikTok, Instagram, and YouTube today, expanding to more platforms to meet our creators where they're at.

The bigger thing is how we match. A niche describes the creator ("fitness influencer" is a label someone filed themselves under). A community describes the audience. Those are different axes, which is why searching and filtering by creator tag feels productive but gets brands nowhere.

So say you make a protein bar. The obvious move is to go search athlete or nutrition influencers. What we'll surface instead is something like nurses... a nurse on hour ten of her shift sells your protein bar better than any athlete does. Same product, totally different community, and it converts because it's her actual life and not a sponsorship.

We can do that because of the creator side. We're already working with creators to build these communities, or they showed up with one already built, so we're not trying to infer a community from a pile of brand mentions. We already know what it is and who's in it, then we match that to what a brand is looking for.

@ceyda299740 Yeah great feedback! When an influencer posts we do show and track the post, and the threads that emerge to show sentiment on how the message is landing beyond just the conversion and reach numbers. We can be better about saying that upfront.

@stefan_stumpfl1 Good question, and there's honestly no universal rate card, which is part of the problem. My advice is to price the work, not the follower count. Start from what you're actually asking for: how many deliverables, how much production effort, and especially usage rights. Rerunning a creator's content as ads is worth real money and it's the thing most brands underprice. For smaller creators, a fair offer is usually less about hitting a magic number and more about being clear up front: the deliverables, the terms, and the budget, instead of making them guess and negotiate blind.

This is also something we help with directly. Trovio guides you toward a fair range for what you're asking, and matching already takes budget alignment into account, so the creators you see are ones where your range and their expectations actually overlap. No markup either, so whatever you offer is exactly what the creator sees. From there creators can accept or counter, and honestly a clearly scoped offer to a handful of well matched creators will calibrate you faster than any benchmark article.

@yasir_khan Honest take: gifting absolutely still works, it just works for different reasons than it used to. Cash has become the norm for bigger asks, but for a lot of creators a product they genuinely want is a totally fair trade for a low-lift post, especially early in a relationship with a brand. We see almost 50% of our first deals on a product exchange.

The key is fit, which is really a targeting problem. A gifting offer to a random creator in your category reads as "work for free." The same offer to someone who actually lives in the community your product serves reads as a perk, because it's something they'd probably buy anyway. That's honestly one of my favorite side effects of matching on communities: when the fit is real, gifting and hybrid deals (product plus a smaller cash component) land really well, and some of the most authentic content comes from exactly those deals. On Trovio you set the terms in your brief, so product-exchange, hybrid, and cash briefs are all totally doable. My advice: product-exchange is a great way to start relationships and test fit, then put cash behind the creators and deliverables that prove out.

Thanks,@laura_butler! Fair challenge, and honestly it's the right question to ask. Most influencer tools are some version of the same thing: a searchable database of creator profiles. You type keywords, filter by follower count, and get back creators sorted by the label they filed themselves under. The tools differ in polish, but the underlying model is retrieval by category.

Three things we do differently. First, we match on communities instead of categories. A niche describes the creator, but a community describes the audience, and one community pulls from a dozen niches. That's a many-to-many problem a search bar structurally can't solve, and it's why the best match for your brand often isn't in the category you'd search. Second, the creators on Trovio aren't scraped profiles. They're actually here, running their business on our creator side with their real accounts connected, so the data is first-party and the conversations happen in one place. Third, the incentives: we take no cut and add no markup, so a $500 brief is worth doing right, not just a six figure one. My honest take is that the difference isn't a feature, it's that the whole thing is built around who your customer trusts instead of who has the most followers.

@suryansh_tiwari2 thanks! Appreciate the support. We think this direction unlocks a ton for creator and brand relationships.

@vanessa_brost Thank you!! Great question. Both happen inside Trovio. When you post a brief you set the terms, and a creator accepting is the agreement, so the scope, deliverables, and price everyone signed up for are documented in the platform rather than living in some email thread. Payment runs through Trovio too. You're not chasing invoices or wiring money to someone you met last week, and the creator isn't chasing you to get paid, which honestly is half the reason smaller deals never used to happen.

And since we take no cut and add no markup, the number in the brief is exactly what the creator receives. We make money on the subscription, not the transaction. Would love to show you more, and happy to answer anything else!

@thys_beesman Hey Brandon, I really appreciate your comments!

You’re right, and this is exactly the kind of failure a healthy-looking loss curve will not reveal.

Arkor Studio does not currently detect train/validation leakage, near-duplicate overlap, or insufficient deduplication automatically. Today, those checks have to be defined in the project’s dataset preparation and evaluation code.

For a framework intended to make fine-tuning accessible to developers who may not already know these failure modes, we do not think that is sufficient. Studio and the framework should provide a preflight layer before GPU time is spent, including split-overlap checks, exact and near-duplicate detection, malformed-example checks, and visibility into eval coverage.

We’re on it.
This is one of the clearest pieces of feedback we’ve received today, and it is helping us prioritize the right responsibility for Studio.

Would you expect these checks to block the run by default, or surface warnings and let the developer decide?

@galdayan Hey Gal, thank you for commenting!

Great point. The intended default is not to store raw training data in the repo. Arkor is designed to reference datasets hosted on Hugging Face, but we also support local JSONL files.

You’re right that local files create an easy footgun. Without the right safeguards, real support tickets or user messages could accidentally end up in Git history.

For a framework aimed at developers who may be new to fine-tuning, we should not leave that entirely to the user.
Adding dataset paths to .gitignore by default, warning when local training files are tracked, and surfacing data-handling checks before training are guardrails we should provide.

This is a genuinely helpful point.

Would a default ignore plus a warning for tracked dataset files address the main risk you’re thinking of, or would you expect stricter handling of local datasets?

@beyzawzzc Hi Beyza!
Thanks so much, that’s exactly the kind of experience we were hoping to create.

I’m curious what you’re building. Are you already using an LLM API inside your product?
If so, what task are you asking the model to handle today, and where does the current model fall short?

@lucapiekarski Thanks, Luca!

We’re starting with Gemma 4 for the first release, mainly so we can make the full workflow reliable before expanding the model catalog.

We’re already hearing requests for smaller models for low-latency or local use, plus voice and vision models, so those are definitely areas we’re exploring.

What are you hoping to build, and which model would you want to fine-tune?

@school_4_ants Thanks for asking, Hunter!

Not yet in the current release.

We launched managed-first so people could go from training to inference without setting up GPUs or deployment infrastructure.

That said, avoiding vendor lock-in is important to us, and downloadable training artifacts are on our roadmap.

For your use case, would downloading the LoRA adapter be enough, or would you also need the merged model weights?

And would Hugging Face / safetensors be your preferred format?

@noctis06 Great questions.

Today, Arkor Studio is a local control surface, but the actual training runs on Arkor-managed remote GPUs. The deployed OpenAI-compatible endpoint is also hosted by Arkor.

We started fully managed so people could try the entire workflow without provisioning GPUs or setting up serving infrastructure.

That said, we do not want Arkor to become a vendor lock-in. Self-hosting and more portable deployment options are on the roadmap.

Claude Code or Codex works the same way it normally does: you ask it to use Arkor to build a model for a specific task, and it edits the files in your local project, prepares the dataset workflow, writes the training script, and runs the project commands. There is no special MCP-only workflow required.

For your use case, would you prefer bringing your own GPU for training, self-hosting inference, or both?

@abdurrahman_fakhrul Hi Abdurrahman, thanks for commenting!

You’re right that the underlying training stack still relies heavily on the Python ecosystem.

Arkor wraps that into a TypeScript framework and managed runtime, so JS and TypeScript developers can build the workflow in their own project and go from training to serving without maintaining a separate Python stack or managing GPUs themselves.

For the initial release, we’re intentionally starting with Gemma 4 so we can make the full experience reliable end-to-end.

We’re already hearing requests for smaller models for lower latency and local inference, and expanding model support is on the roadmap.

What would you want to fine-tune, and for what kind of use case? A specific model family or size would be especially helpful as we decide what to support next.

@omri_ben_shoham1 Hi Omri! That’s a fair challenge.

Studio lets you inspect training and validation loss, but loss alone cannot tell you whether the model generalized or simply memorized the training set.

You’re also right that “no ML expertise required” is too broad.

What Arkor removes today is the need to maintain a Python training stack, provision GPUs, and build the training and serving infrastructure yourself. A meaningful held-out eval set and task-specific success criteria still matter.

One reason we started with the Gemma 4 was to keep the initial use case focused.
A common workflow is to use a larger model to generate or label examples for a clearly defined task, then fine-tune a smaller model to reproduce that behavior. We think that can work well for application-level semantic tasks such as classification, extraction, routing, and rewriting.

We also think evaluation needs to become a first-class part of the Arkor framework. Projects should be able to define task-specific evals in code, while Studio surfaces base-vs-adapter comparisons, data leakage and duplicate checks, and signs of overfitting before deployment. We are not fully there yet, but this is an important direction for us.

Thanks for pushing on the claim. We're going to position this more clearly.

What would be the most useful first step for you: automated dataset checks, base-vs-adapter evaluation on a held-out set, or support for custom task-specific metrics?

@aditya_harish_2002 Hey Adithya! I really appreciate your comment.

This is a very fair point.
Studio shows training progress and loss today, but it does not yet take responsibility for detecting train/validation leakage, near-duplicates, or weak eval coverage before a run.

Right now, those checks need to be implemented in the project’s data preparation and evaluation code.
But for a framework designed for developers who may be new to fine-tuning, leaving all of that to the user is not good enough.

We believe dataset validation and evaluation should become first-class parts of both the Arkor framework and Studio.
Preflight checks for split overlap, duplicates, malformed examples, label and scenario coverage, plus held-out base-vs-adapter evaluation, are exactly the direction we’re working toward.

We’re on it, and this feedback helps us prioritize it. Thank you.

What would be the minimum preflight report you’d need before trusting an agent-prepared dataset?

@umechanhika  The quiet/no-banner design is a nice choice for multi-agent work. One edge case I would want to test is remote Claude Code inside tmux: if the state file syncs back but the jump target cannot map to the right pane, does AgentManager still show it as needs attention without trying to focus the wrong window?

@omri_ben_shoham1 

You've described my pre-AgentManager life exactly 😄 And yes — they're fully distinct states, styled by urgency. "Needs input" is amber: a pulsing glow, a stripe on the row's edge, and the one short meow. "Just finished, fyi" is green and completely silent — the row turns calm, the window surfaces so you notice, but nothing chirps at you. Blue means "still working, don't touch."

One subtle case I made sure of: when a session finishes and then just sits there, Claude Code emits an idle notification — that stays green. A finished session never escalates itself into fake "needs input" just because time passed. The amber signal only ever means a real blocker: a permission prompt, a plan approval, or a question waiting on you.

@qifengzheng 

You've found the real seam, and I won't pretend otherwise. What AgentManager does about the shared-file half: registration is a merge, not a write — it checks whether its command already exists per event, appends alongside other tools' hooks without touching them, and the edit is a text splice that only modifies the top-level hooks key, so your formatting, comments, and symlinks survive. A .bak is written first, and if the JSON doesn't parse, it refuses to write at all rather than "fix" a file other tools depend on.

One deliberate choice against dangling: the hook script and binary are installed under ~/.claude/agent-manager/, not inside the app bundle — so moving or deleting the .app doesn't leave settings.json pointing into a Trash'd bundle, and the path is written as $HOME/... so it survives machine migrations.

But the uninstall half of your point stands: today there's no one-click unregister, so fully removing AgentManager means cleaning its entries out of settings.json yourself. That's exactly the stale-path scenario you're describing and it deserves a proper "remove hooks" button that does the surgical reverse of registration. It's going on the list — this is the most technically useful comment on the page, thank you.

@noctis06 

This is genuinely useful — you've basically written the integration sketch for me. Codex CLI's notify config is exactly the kind of seam I'd want: a small state-writer emitting the same JSON into the watched directory, and the app wouldn't even know the difference. The homework on my side is mapping its events onto the four-state model without cheating — the value here isn't "a session exists," it's the reliable distinction between blocked on you, working, and done, plus resolving the jump target the same way. If Codex's events carry enough signal for that, it slots in; if they don't, I'd rather wait than ship a lamp that lies.

And agreed on Aider — no lifecycle events means it stays out on principle, not out of laziness. Thanks for taking the time on this thread; Codex just moved to the top of the "next agent" shortlist.

@dndcltj 

On the "which session needs me" part — the state lamps are already there: every row has a colored light next to the project name, and the waiting one is a pulsing amber glow with a stripe down the row's edge, so it catches your eye before you've read anything. Blue with a slow breathing animation means "working, leave it alone." And that thinking-vs-waiting distinction is structural: state comes from Claude Code's own hook events, so a long thinking step or tool call stays blue — amber only fires on explicit signals like a permission prompt or a question to you. No false alarms mid-stream.

But if what you're after is telling which project is which without reading names — like a distinct icon or color per project — that doesn't exist yet, and it's a genuinely good idea. Right now identity is the project folder name plus stable row order (rows never reorder, so muscle memory does a lot). A per-project visual mark would make that instant. Adding it to the list — and tell me which you actually meant, I'm curious now 😄

DND is a good call too: there are no Notification Center banners at all and the meow is mutable, but auto-quieting during a macOS Focus session would be the polished version. Noted!

@ozandenizm84853 

Thank you! "Low-key" is the highest compliment for this app — the bar I set was that a good Mac utility should feel like part of the OS: show up exactly when needed, disappear the moment it's not, and never ask for attention it hasn't earned. That's also why there are no Notification Center banners — the window appearing quietly is the notification.

Hope it keeps your stuck sessions from hiding on you 🐈

@ege_karama27779 

Thank you — that's exactly why it had to be native. An app whose job is to appear and vanish dozens of times a day, while living permanently next to your real work, has no business shipping a browser runtime with it. Swift + AppKit keeps the panel instant and the footprint tiny, so it earns its spot as a resident instead of competing with your actual tools for resources.

(Also, pixel-art cats deserve to be rendered natively. It's a matter of principle 🐈)

@talhakhalidmtk 

One window, all sessions — each gets a row with its own state light, and the list grows as sessions come and go. No per-session windows to manage.

Noise was actually the main design constraint, because the whole point is that you're juggling several agents and the tool shouldn't add to it. So: the window hides itself whenever nothing needs you and only surfaces when a session is waiting or finished. There are no Notification Center banners at all. And the sound alert is a single short meow with a global debounce — if three sessions hit "waiting" at once, you hear one meow, not three. The more agents you run, the more that restraint matters.

@sebahat45760404 

Thanks! Good news for the build/deploy case specifically: you may not need to watch it at all. The moment a long-running session finishes, it flips to "done" and the window surfaces on its own — completion is treated as an event worth your attention, same as waiting for input. And while it's running, the menu bar keeps a live per-state count, so a glance tells you it's still going without any window open. ⌥Space summons the full list any time you want a closer look.

That said, "keep it visible, I just want to watch" is a fair and different ask — and you're actually the second person requesting a pin option today, which officially moves it up the list 😄 Auto-hide is the default because staying quiet when nothing needs you is the app's whole personality, but an opt-in pin wouldn't fight that. Thanks for the concrete use case!

@abdurrahman_fakhrul 

Mac only, and honestly it's likely to stay that way for a while. The app is built around a strict "nothing leaves your Mac" rule — no server, no network, session state is just local files. Pushing notifications to an iPhone would mean routing your session activity through some backend, and that's a privacy tradeoff I don't want to make casually.

It's also a slightly different problem: AgentManager is built for the at-your-desk case — you're juggling sessions and other work on the same machine, and it surfaces the one that needs you. If you're away from the Mac entirely, a blocked session usually isn't something you can act on anyway (the terminal's back at your desk!). That said, if "know before I walk back" is a real need for you, I'd love to hear the scenario — it'd have to be designed carefully, but I'm listening.

@krekeltronics 

"Boring infrastructure" is the nicest thing you could call it — that was the design brief, verbatim. A tool that sits between you and approval prompts has no business being clever.

On session identity, since you brought it up: each session is keyed by Claude Code's own session ID, and the hook records the owning claude process's PID plus its start time — so if a PID gets recycled by the OS, a dead session can't masquerade as alive. Sessions whose process vanished without a clean SessionEnd get swept out automatically. And the jump target is captured at hook time, not guessed at click time — e.g. the exact iTerm2 pane GUID is resolved by walking the process tree when the event fires, so the click lands where the session actually lives.

State files are written atomically to a local directory, the app just watches it with FSEvents, and there's no daemon and no network in the loop. If it ever stops being boring, that's a regression 😄

@galdayan 

Honest answer: strictly local right now. The hook fires on the machine where Claude Code runs, so in an SSH session it would run remote-side and write its state file to the remote filesystem — which the Mac app never sees, since it just watches a local directory. So installing the binary remotely wouldn't help today; you'd get state files stranded on the server.

Could it work? Partially, in principle. Detection is just JSON files in a directory, so a synced/mounted ~/.claude/agent-manager/sessions/ could carry remote state to the Mac — that half is plumbing. The hard half is the jump: locally the hook walks the process tree to find the exact terminal pane, and that chain breaks at the SSH boundary. Mapping a remote session back to the local terminal that's SSH'd into it needs a different mechanism, and I'd rather not ship a jump that lands on the wrong window.

You're right that this is where menu-bar tools usually stop, and a local+remote mix is a real workflow — it's on my radar. Out of curiosity: are your remote sessions inside tmux/screen on the server, or plain SSH in a local terminal tab? That changes which approach would actually be reliable.

@dhiraj_patel5 

Thanks! Honest answer: no near-term plans. AgentManager is native Swift (SwiftUI + AppKit) on purpose, and the parts that make it feel good are exactly the parts that don't port — the always-on-top panel, FSEvents watching, and the terminal-jump layer built on macOS Automation/Accessibility APIs. A Linux or Windows version wouldn't be a port, it'd be a second app written from scratch.

The one honest caveat: the concept is portable. Detection is just Claude Code hooks writing local JSON, nothing Mac-specific about that half. But as a solo dev I'd rather make one platform genuinely excellent than three platforms mediocre — so for now, Mac gets all of it. If demand elsewhere gets loud enough, that math can change 😄

@araczeliha97691 

Good news — the sound already exists, and it's the app's signature move: a subtle cat meow (~0.35s) the moment a session starts waiting 🐱 It's mutable if meows aren't your office vibe, and if several sessions hit "waiting" at once it's debounced so you get one meow, not a chorus.

On the buried-window worry: the floating window is always-on-top, and it re-surfaces in front the moment any session needs you — so it can't actually get lost behind other apps. Between the meow, the auto-surface, and the live counts in the menu bar, I deliberately skipped Notification Center: banners pile up, get swiped away, and end up as one more inbox to ignore. The window appearing is the notification, and it disappears once you've handled things.

Give the trial a spin and tell me if a waiting session ever actually slips past you — if it does, that's a bug in my book and I want to hear about it.

@erengilsed11978 

Thank you! "Not bolted on" is exactly what I was going for — the app only speaks up when a session actually needs you, and gets out of the way the rest of the time.

And "native" goes all the way down: it's Swift (SwiftUI + AppKit), the whole download is ~2.5 MB, and everything runs locally on your Mac. The tab-switching tax was the whole reason I built it, so it's great to hear it lands.

@ark_y_k 

Exactly the annoyance that made me build it 😄 And no individual checking needed — every session registers automatically and they all live in one floating window, each with its own state light. The moment any of them starts waiting, the window surfaces with that row pulsing amber; when nothing needs you, it hides itself. The menu bar shows a live count too, so even with the window hidden you can see "3 running, 1 waiting" at a glance.

Small detail I'm fond of: if several sessions hit "waiting" at nearly the same time, the sound alert has a global debounce so you get one meow, not a chorus. From the window it's one click to jump to the exact terminal (iTerm2 pane, VS Code window, etc.) that needs the answer.

@senargf3 

Good news on half of this: sessions never leave the list while they're alive — idle ones stay right there as grey rows, and every row is labeled with its project folder name. So "which window belongs to which project" is exactly what the list answers: glance, click, and you're in that project's terminal. The window itself is also one ⌥Space away at any moment, even when it's auto-hidden.

The other half — keeping it visible through idle instead of auto-hiding — is a fair ask. Auto-hide is the default because "quiet when nothing needs you" is the app's whole personality, but a pin option for people juggling two long-running tasks wouldn't fight that. Adding it to the list — thanks for the concrete use case, that's the kind that actually shapes the roadmap!

@alieksia 

Thank you! 🙌 And yes — a clean finish is a first-class event, not just blocked-waiting. When a session finishes, its row turns green and the floating window surfaces the same way it does for waiting; it only hides when there's nothing left that needs your attention. The menu bar also shows a live count per state, so you can see "2 running, 1 done" at a glance.

One detail that matters for long pipeline jobs: "done" isn't premature. If the main response stops but background subagents are still working, the session stays "processing" and only flips to done when the last one actually finishes.

The only thing reserved for waiting is the sound alert — a finished session surfaces silently, so a long run ending doesn't interrupt whatever you switched to. If you'd want an optional sound for completions too, that's an easy toggle to consider — tell me and I'll put it on the list!

@aidan_codefox 

Finally, someone here for the right reasons 😄

And honestly… that's not even a joke to me. The meow is procedurally synthesized (no audio files), so giving each session its own pitch is genuinely doable — your refactor session as the deep old tomcat, the test runner as the anxious kitten. Adding it to the list, and I can't believe this is now a roadmap item. Thank you.

@andrewzakonov 

Thanks — "hides when all is clear" was actually the starting point of the whole app. The alert part is easy; the quiet part is what makes it livable.

Honest answer: no ranking. All sessions live in one list in a stable order (by launch time), and rows never reorder on state changes — waiting ones just light up with a pulsing amber stripe. That's deliberate: with a handful of parallel sessions, reordering would break your spatial memory of "top row = the refactor, second = the tests", and you'd misclick jumps. A stable list you can scan in a second beat every ranking scheme I tried.

In practice you glance at the amber rows, click the one you care about, and you're in the right terminal. If you'd find explicit prioritization (e.g. "waiting longest first") genuinely useful though, I'm open to it — that's exactly the kind of feedback I'm here for.

@noctis06 

Great question! It's neither — no TTY scraping, no process hooking. AgentManager uses Claude Code's official hooks: it registers them in ~/.claude/settings.json, Claude Code invokes a tiny binary on every lifecycle event (prompt submit, tool use, notifications, stop…), that writes per-session state to a local JSON file, and the app watches it with FSEvents. No polling, no daemon, no network — everything stays on your Mac.

False "waiting" can't really happen because state is never inferred from output or silence. "Waiting" only comes from explicit signals — a permission prompt, a plan-approval dialog, or an AskUserQuestion call. A long tool call just fires PreToolUse and stays "processing" until it finishes, no matter how long it streams. Trickiest edge case was background subagents that outlive the main response — those are tracked too, so sessions don't flip to "done" early.

Happy to go deeper if you're curious!

@aditya_harish_2002 

Thank you! And you nailed the design bet — alerts alone just move the problem ("now I have unread alerts"). The jump is what closes the loop, so I spent a silly amount of time on precision: iTerm2 lands on the exact pane, Terminal and Ghostty on the tab, VS Code / Cursor / Zed on the right project window.

And yes, Simple mode exists precisely for screen-sharing-with-your-manager moments 😄 The cats will wait for you.

@omri_ben_shoham1 Thanks, I really appreciate that!
Especially your point about consistency needing something more meaningful than a streak number.

The sessions aren’t fully anonymous. Before joining, you can see a live feed of who’s there and what they’re working on. Tasks are public by default, but users can turn that off in Settings.

Once you join the session, the feed disappears so it doesn’t become another distraction. You still know others are focusing with you, but the interface gets out of the way.

@leo404 At 2:14, you wouldn’t need to wait until 2:30 — the next Light Roast 15/5 session starts at 2:15, so you could jump in almost immediately.

You can also start a Solo session or a free-form Timer at any time. Those stay separate rather than automatically folding into the next global block, so the choice is between joining the shared rhythm or starting immediately.

Coffee is a real session budget, not just cosmetic XP. I designed it to make each focus session feel intentional, rather than something you start and abandon without thinking.

At the same time, every completed session charges the Grind Machine, which can unlock unlimited coffee for a day or longer as a reward. That creates a kind of release valve: periods of intentional limits, followed by a more relaxed stretch where you can focus as much as you want.

@ilko_kacharov Thanks, Ilko! Really glad that resonated!

@abdurrahman_fakhrul Thank you! You can see more than just the timer. There’s a lightweight activity feed with other people’s avatars and what they’re currently working on, while the session itself shows how many people are focusing alongside you.

I’ve intentionally kept it minimal, no chat or busy social feature, so it adds presence and accountability without becoming another distraction.

@galdayan That’s a fair concern - I don’t want Grindoro to punish people for missing a day.

Coffee refills daily, so skipping a day doesn’t create a hard energy penalty. For the weekly café, simply opening the app counts as a visit, and you only need 5 visits per week - so you can miss 2 days and still collect it.

There is a daily streak, but missed days can be covered by streak shields. You collect shield fragments after focus sessions and combine them into shields, so one busy day doesn’t automatically erase your progress.

The goal is to reward returning and doing meaningful focus work - not create anxiety around maintaining a perfect chain.

@mertrstemobygx 

Thank you! That sense of quietly grinding alongside others is exactly what I wanted to create.

There’s also a small community-support mechanic around coffee. During a session, you can share a coffee with someone who’s running low, and sometimes another person may send one to you. It’s a lightweight way to help each other keep going without adding chat or turning the app into a social network

@dhiraj_patel5 Yes! If you join late, you enter the session at its current point, so you sync to the shared timer instead of restarting it for yourself.

You can see that in the Live Activity too: the faded part on the left shows the portion of the session that had already passed before you joined, while the highlighted part shows your active segment. The same idea also carries into your stats, so it’s clear when you joined and how much of the shared session you actually completed.

@ark_y_k Right now, there’s no goal-based matching or private friend groups. Everyone joins the same global session at the scheduled start time - usually on the hour or half-hour - alongside whoever else is focusing then.

I also don’t want users spending time deciding which room or group to join. Their main task is to focus, so the social layer should require almost no setup.

You can see the shared participant count and a lightweight view of what some people are working on, but everyone stays in the same shared rhythm. The idea is accountability without adding more decisions or distractions.

@hava3cfd Thank you! That’s exactly the feeling I was aiming for: enough shared presence to make focusing feel less lonely, without adding the distractions of a social network.

And yes, the cafés are meant to turn consistency into something you can actually collect and look back on, together with your focus stats from each week.

@busmark_w_nika It’s more like a shared focus room than a peer tracker. You track your own tasks, sessions, and progress, while Global mode shows how many other people are focusing at the same time.

There’s no chat or social feed to distract you, the idea is simply to make a solo session feel like you’re working alongside others.

@sergbmw That’s a really good distinction. Right now, the recap focuses mostly on what was completed, but showing planned focus time alongside completed rounds could make it feel more honest and useful.

I especially like that it adds accountability without punishing people for breaking a streak. I’m adding this idea to the post-session recap list.

@aditya_harish_2002 Thanks! That shared rhythm is exactly what I wanted the fixed start times to create.

Right now, cafés are mostly collectible proof of consistency. Each week has a new café, and completing at least one focus session during that week adds it to your seasonal passport.

Each café also keeps a snapshot of that week: focused time, sessions, visits, and cups used. You can swipe through the café carousel later and look back at both the places you collected and your progress during each week.

They don’t currently affect session matching. Everyone still joins the same shared focus rhythm, while cafés add a longer-term reason to return each week. I’m curious whether cafés shaping smaller groups or shared routines would make the mechanic more interesting to you.

The proof happens on the dev's own machine: the open-source CLI reads the git history right where it lives and turns it into metadata (skills, activity, time spans, never code). Then they defend that work live, answering questions about their own decisions. So the claim gets tested without the repo ever going anywhere.

Btw if you ever feel like helping us harden the evidence, the CLI is open source, happy to have you there: github.com/Redential/redential-cli

@kaplaneylu22927 Hey eylul! So today it's repo by repo: nothing enters your profile unless you scan and submit that repo, so you already control what's in.

We stopped there on purpose though: the moment evidence can be hand-picked commit by commit, it stops being evidence and turns back into a curated portfolio, which is kinda the problem we're replacing.

Curious about your use case though: is it more about hiding noise, or highlighting the most relevant work for a role? Because the second one is a presentation feature we could build without touching the evidence, and tbh it's a good idea.

@luyuan_liu This is exactly who we built it for tbh. Self-taught devs have the strongest proof there is (the work itself) and nowhere to point to it. Run npx redential scan on your repo, takes a minute, no account needed, and you'll see what your history says about you. And congrats on YOUR launch today, big day for both of us!

@omri_ben_shoham1  Thanks Omri! Really appreciate it. The defense is where we're putting most of the work, first one is free if you want to try it on your own repo.

If you want to contribute to our open source repo, happy to have you there!

@mateuszkonik Timing matters tbh: the CLI reads local git history, so the move is to scan while you still legitimately have the repo on your machine (most devs scan before wrapping up a job).

Once you've lost all access there's nothing local to read, we can't conjure evidence from nothing. What you keep forever is the credential you built while you had it: the bundle lives on your profile, not in their repo.

And yes, sharing is the whole point: your profile is a link, anyone you send it to can open it, no account needed on their side.

Actually you just gave me an idea: I opened an issue for this ("how do you preserve evidence before losing access?") and see what the community comes up with. That's how our best improvements happened so far.

@hi_i_am_mimo Yep, filtered before anything is summarized. Skills only attribute from lines YOU actually added: vendored deps, generated files and other contributors' code never enter the analysis (author filter + path exclusions, all public in the repo). Co-authored commits inherit git's one-author-per-commit model, that's the honest limit. And it's all Attested-tier anyway: labeled claims, not verdicts.

@aidan_codefox Depends on the evidence. From a CLI bundle the engine only sees metadata, so questions are architecture-level (why Redis, what breaks at 10x). From a connected repo it sees real files and mined fix history, so it gets specific, exactly your "why exactly-once here" type.

First question is deterministic from your detected capabilities; follow-ups are generated one at a time from the live transcript, so it drills into your last answer (capped at 3 levels per topic, server-side). Max 10 questions in 10 minutes, including one counterfactual that inverts a real fact from your history to catch people who agree with anything. Every positive verdict needs a literal quote from what you said, rules can only lower a verdict, and the model alone can never grant the top tier: Verified requires deterministic commit evidence. No human review today, that's the honest state.

On ghostwriting: we think the axis moved. The question isn't "did you type it" but "did you direct it and can you defend it". The bundle carries honest agent-involvement signals, and the defense tests exactly the part a ghostwriter can't sit for you.

Thanks for the feedback btw happy to hear more

@tehreem_fatima5  The CLI is git-based, not GitHub-based: it reads local git history on your machine, so GitLab, Bitbucket and self-hosted repos already work. Only a small metadata summary you review ever leaves, no code, no file names, which is exactly the point for strict compliance setups. If you meant the sign-in or the connected-repo GitHub App, those are GitHub-first today with more planned. Which part did you have in mind?

@shahrukh_khan39  Tbh that's a real constraint and I won't tell you to sneak it past IT, that's not our vibe. Good news imo: this is the easiest kind of tool to get approved. Nothing installs (npx runs it once), scan makes zero network calls, and it's fully open source so your security team can literally read every line and run the privacy tests themselves. Btw a few folks have gotten it greenlit exactly that way, worth a quick ask to your sec team.

You can check our open source repo here.

@thys_beesman Yeah, so local evidence can't prove you lived it, so it's our weakest tier and labeled that way. Two things help tho: scan only counts commits YOU authored (a reviewer scanning that repo gets a thin profile), and claimed emails get checked against your verified ones. The hard-prepper gap is real. Our bet: memorizing months of someone else's decisions well enough to survive live follow-ups is almost as much work as doing the work. Narrows, doesn't close. Honest state of it.

Squashed/rebased repos: no "can't verify" verdict, you just get a thinner profile (fewer commits, capabilities still detected from the diffs). And squash-merge workflows are explicitly documented as benign in the forensics, what looks bad is years of history committed in one sitting. Migrated repos land as weaker evidence, not invalid. It's all in docs/schema.md so if you wanna poke holes, best kind of contribution for us.

One more thing: replayed histories usually leave every committer date clustered in one sitting even when author dates span years, and the bundle ships both spans. A careful forger can fake both dates though, git allows it. That's exactly why local evidence is the weakest tier by design and the live defense sits on top. We never claim to detect all forgery, we claim to label what we can't verify.

@abdullah_javaid3 You're right: at the Attested tier there's no ground truth outside the artifact, that's why it's the floor tier and labeled that way. What the CLI does is raise the price of the fake: signed commits can't be backdated without your key, replayed histories leave a committer-date signature the bundle ships, and the structural signals need real connected code (a webhook flow that verifies, writes and dedupes across files), not plausible-looking commits.

Also the session throws you a counterfactual (inverts a real fact from your history) and drills into your own answers, so a fake has to stay coherent under pressure. At that point faking it is basically.. doing work.

You got us on the recency thing. Today a 2019 repo gets the same depth as last month's. You basically wrote our next design issue. Wanna write it up for real? Issue #28 in the repo, that's exactly the contribution we want most.

Thanks for your feedback

@vollos Thank you Chalermpon! So teams don't request defended profiles, and there's no pending review that later goes public. Devs defend their own work, and the only public thing is the dev's profile, which the dev owns and shares.

What teams get is an API: invite a candidate with a magic link, read the result of your own sessions only. Every API key belongs to one company and every read is filtered by it. Plus a private workspace to review your own candidates, with the defense audio and evidence behind each credential.

So no, another team can't pull up someone else's pending review. There's simply no shared pool to pull from.

Happy to hear what you think, and if you like to chat just schedule here

@galdayan hey gal, thanks. one factual fix first: the bundle never says "connected to auth via X", that example overshoots. What actually leaves is a closed-vocabulary slug (payments/payment-webhook-flow) and that's literally the whole disclosure. No architecture graph, no system connections, nothing.

So: the vocabulary IS the ceiling. it can only name industry-standard patterns (the taxonomy is public in the repo), so what gets out is "their front door has a lock" level stuff. Anything bespoke straight up can't be expressed, there's no slug for it, and adding one takes a public discussion plus schema ceremony. The leak surface is fixed and auditable, not open-ended.

On employer say: honest answer, nope. It's the individual's call, same as listing skills on a CV always has been, and the scan makes them confirm they're authorized. the way we think about protecting the company side isn't a veto, it's the ceiling: the tool literally can't surface more than CV-level facts. Does that cover what you'd actually worry about, or is there a case you're seeing that I'm not?

Btw this is exactly the feedback that's been shaping the product all week, keep it coming. And give the scan a try on any repo, takes a minute, no account: npx redential scan

@abdullah_javaid3 Attribution is by author email.

Possession can't be identity: everyone who clones a repo "holds" it, so possession-based attribution would let anyone claim any history they can download. Your case is the painful flip side: from the outside, "my commits carry my colleague's email" is indistinguishable from "I'm claiming my colleague's commits", and we refuse to guess.

So yes, today the CLI inherits git's wrong answer for that stretch, same as every tool. The one thing we add: you can claim multiple emails that are YOURS (they get checked against your verified addresses), which covers the common multi-email mess, just not the someone-else's-email one.

It's a real gap and more common than people admit, like you said. If you've got ideas for an honest fix (colleague attestation? signed retro-claims?), that's exactly the kind of thing issue #28 exists for.

@abdurrahman_fakhrul Two paths today: the open-source CLI (for NDA work you can't show) and the GitHub App for repos you can connect. The App gives stronger verification because we can read the actual code. The CLI earns a lower, clearly labeled tier because local evidence is forgeable by nature, and that's exactly why it's open source: so people can red-team it, and we actively invite that in the repo.

The genuine check is the live defense: video and audio, recorded on your profile. Our AI generates questions from your real history (possible bugs, how you'd solve X, why you made this decision) and matches your answers against your commits. With a connected repo that matching is strong. With the CLI it's harder, which is why it stays the lower tier and why we harden it in public.

Before any of that, the basics: only commits YOU authored count, the emails you claim get checked against your verified addresses, signed commits can't be backdated without your key, and replayed histories leave a date signature the bundle ships.

Happy to have you as a contributor in our open source repo

@kyle_bennett6  TBH, I apply the Willie Sutton rule. (When asked why he robbed banks, he replied, “Because that’s where the money is.”) :) If it becomes a hit on iOS/tvOS I will look at an Android port, but until then it’s tough to justify the development/testing expense and complexity.

@dustin_warren Ha, yeah. But the truth is it’s mostly military transports. Fighters typically don’t advertise their location.

@derek_julian I’m not so sure—I think it’s just two different usage modes. I myself use the iPhone app many times daily, but only for a few seconds each time, and always to answer the question, “What’s that plane hear?” But I also leave it running on the Apple TV in my office for hours at a time.

@azizvwhr Thanks! It’s been really fun to work on.

@abdurrahman_fakhrul There’s a tiny bit of latency, but it’s near-real-time.

@omri_ben_shoham1 Fair concern. I use the iOS system heading as-is, but it’s not just raw magnetometer data. CoreLocation combines the magnetometer with the gyro and accelerometer, which handles most short-term drift. If it becomes an issue, I could use the heading-accuracy estimate reported by iOS, but no one (other than you) has reported trouble with it so far. Are you seeing heading accuracy issues? If so, what device are you using? Thanks for the feedback!

@cemgmlcnehrtm Thanks, that’s the feel I was going for.

@abdullah_javaid3 That split was observed during the beta when all features were available to all users. Yes, you can purchase directly thru the Apple TV interface—no phone handoff required. Thanks for the comments!

@aditya_harish_2002 Interesting inbounds don’t happen very often for most people, but when they do they’re pretty exciting. (The spoken traffic voice announcing it is even excited. 😊) thanks for the comments!

@koglu5218 Glad to hear you’re liking it! I’m curious: do you have spoken traffic turned on? I do that and then the volume down low. It’s nice background noise while I work, and just the right amount of interesting. :)

@hafizekang6uei That would cool! I’ll put that in the feature-request hopper.

The @ mention batch processing is the standout feature here, comparing sources without manual copy-paste is a real time-saver. But for academic work, that convenience carries a real risk: if the AI conflates or misattributes a point across multiple papers, that's not just noise, it's a citation error.

How does Lattics handle attribution when synthesizing across documents? Does it flag which source each point actually came from, or is verifying that still on the writer?

@aditya_harish_2002 You can use Ollama or your own deployed model as AI provider, and only you choose content send to model, unless you authorize AI acess some projects, but it is all under your control.

@galdayan You can use Ollama or your own deployment model as AI provider

@tekelioglu84719 We welcome you to try Lattics and write a review. Here is a redemption code for a Lattics Pro monthly membership: fkHbk03usf, which can be redeemed at this link: https://lattics.com/en-US/reseller/redeem

@abhineetarora Currently, users can create content non-linearly and visually, manually establishing connections between different parts. In the future, AI will enhance automation, but humans will still retain control.

@robin_de_lacroix Yeah, same fellings. I am the heavy user of Lattics, 5 years ago, we start design and develop it, based on our expectations for long-form and serious writing

@abdurrahman_fakhrul Integrate with knowledge graph is our next step, and will be context perception automatically

@jerome2000 Yes, It keeps the layout same as original docs, and include scanned pages

@boran4dda I love the idea of a small vibration alert for irregular heart rate or high stress moments. I hadn't considered a screenless fitness tracker before, but a feature like that would make me consider it.

@sayyids an API would be great.

@ilk_l13311 that is quite something and I don't want to hand-wave it. What you're describing isn't a small add or a feature behavior tweak. A branchable, navigable transcript where you can grab a specific moment and carry it into a follow-up is a real product surface: timeline, quote-linking, threading a call moment back into chat. Genuinely interesting, and not at all trivial :)

Today: we've got live captions / transcription (β) for calls (English), that's the raw material the flow you're describing would sit on, but it's the groundwork, not the whole thing.

 If you can walk me through how your team would actually move through it right from reviewing a support call, to pulling a sales quote, and what a "jump back" looks like in practice I'll take that straight to the team.

A concrete flow is worth far more than a feature request here. Really appreciate you thinking at this depth 🙏

@bnyaminndejjqk  

Okay this is the comment I was hoping someone would leave 😀

You're describing two things: a real replacement for Slack/Teams, and not losing your history in the switch.

We've got both.

The replacement is CometChat Air → https://www.cometchat.com/air - team chat that never leaves your walls. Channels, DMs, threads, voice/video with recording, full-text search, in-chat AI - self-hosted or fully air-gapped, built for teams that can't put their conversations in someone else's cloud. And because Air is aimed squarely at regulated environments, it's built to the compliance bar those team actually need — ISO, HIPAA (with BAA), GDPR, AICPA/SOC, PIPEDA, COPPA.

If "considering CometChat as a Slack replacement" is the thought, Air is that product.

 On the years of history, really not the blocker it feels like. Migration is white-glove: our team brings your existing messages, users, and groups across for you, so you land in Air with your past intact instead of a blank workspace. You don't DIY it.

If you tell me where you'd be coming from (Slack? Teams?) and rough scale, I'll get you connected to the right folks at CometChat.

@abdurrahman_fakhrul Thanks for seeing it the way we intended it :)

On developer control, it goes pretty deep.

Two ways in: build the agent natively in our Agent Builder, or bring your own (OpenAI, LangGraph, Mastra, CrewAI, Vercel…) and run it headless or with our UI. It's model-agnostic, so you can swap providers/models without touching the customer experience.

  
Behavior itself is shaped by:
- Instructions: tone, guardrails, hand-off rules, how it should respond. You can @-mention specific tools/MCP resources inline so the agent knows exactly when to use each one.
- Tools: call any REST endpoint, with templated context ({{uid}}, {{role}}, message metadata) injected into the request.
- MCP endpoints: connect external services/knowledge bases for richer, live context.
- Frontend actions: the agent can drive your UI (open a modal, navigate, fire a notification), not just reply with text.

So it's not a fixed bot you skin, it's the behavior, the tools, the model, and how it acts on your app, all in your hands.

Docs if you want to dig in:   

  - Overview: https://www.cometchat.com/docs/ai-agents

  - Agent Builder: https://www.cometchat.com/docs/ai-agents/agent-builder/overview

  - Instructions: https://www.cometchat.com/docs/ai-agents/agent-builder/instructions

  - Tools: https://www.cometchat.com/docs/ai-agents/agent-builder/tools/overview

  - MCP: https://www.cometchat.com/docs/ai-agents/agent-builder/mcp/overview

  - Frontend actions: https://www.cometchat.com/docs/ai-agents/agent-builder/frontend-actions/overview

What are you looking to build? Happy to point you at the exact layer.

@hasanfia0 Thanks for the love :) Yes that was a very conscious decision from the early stages of our roadmap.

The event plumbing is already there, webhooks fire on messages, user and group activity, calls, even moderation results, so the signal you'd want to route absolutely exists today. What's missing is the part you're actually pointing at: a no-code layer on top so a non-dev can wire "this event → that tool" without standing up an endpoint and pinging engineering every time.

What are some workflows that you were thinking of solving?

@minh_nguyen84 Actually, this is the most interesting part. I designed a magnetic 3D-printed phone case. Once installed, you can only focus—even if you want to browse TikTok, the protective case will make you give up. This isn't a coercive measure, but the psychological hint will constantly remind you of unconscious behaviors, quickly interrupting addictive patterns. After launching in China, I had over 10 testers, and their feedback was quite effective. When you really need to work or want some appropriate entertainment, you can attach the phone to the back and return to the smart device.