🗣️ Post 1: Launch HN: Societies.io (YC W25) – AI simulations of your target audience

As posted by: p-sharpe  |  🔥 Points: 97

🔗 https://news.ycombinator.com/item?id=44755654

💬 Summary

Hi HN, we’re Patrick and James! Artificial Societies (https://societies.io) lets you simulate your target audience so you can test marketing, messaging and content before you launch them.

Here’s a quick product demo: https://www.loom.com/share/c0ce8ab860c044c586c13a24b6c9b391?...

Marketers always say that half their spend will be wasted - they just don’t know which half. Real-world experiments help, but they’re too slow and expensive to run at scale. So, we’re building simulations that let you test rapidly and cheaply to find the best version of your message.

How it works:

- We create AI personas based on real-world data from actual individuals, collected from publicly available social media profiles and web sources.

- For each audience, we retrieve relevant personas from our database and map them out on an interactive social network graph, which is designed to replicate patterns of social influence.

- Once you’ve drafted your message, each experiment runs a multi-agent simulation where the personas react to your content and interact with each other - these take 30s to 2 minutes to run. Then, we then surface results and insights to help you improve your messaging.

Our two biggest challenges are accuracy and UI. We’ve tested our performance at predicting how LinkedIn posts perform, and the initial results have been promising. Our model has an R2 of 0.78 and we’ve found that “message spread” in our simulations is the single most important predictor of actual engagements when looking at posts made by the same authors. But there’s a long way to go in generalising these simulations to other contexts, and finding ground truth data for evals. We have some more info on accuracy here: https://societies.io/#accuracy

In terms of UI, our biggest challenge is figuring out whether the ‘experiment’ form factor is attractive to users. We’ve deliberately focused on this (over AI surveys) as experiments leverage our expertise in social influence and how ideas spread between personas.

James and I are both behavioral scientists by training but took different paths to get here. I helped businesses run A/B tests to boost sales and retention. Meanwhile, James became a data scientist and, in his spare time, hooked together 33,000 LLM chatbots and wrote a paper about it (https://bpspsychub.onlinelibrary.wiley.com/doi/pdfdirect/10....). He showed me the simulations and we decided to make a startup out of it.

Pricing: Artificial Societies is free to try. New users get 3 free credits and then a two week free trial. Pro accounts get unlimited simulations for $40/month. We’re planning on introducing teams later, and enterprise pricing for custom-built audiences.

We’d love you to give the tool a try and share your thoughts!

🗣️ Post 2: Show HN: TraceRoot – Open-source agentic debugging for distributed services

As posted by: xinweihe  |  🔥 Points: 36

🔗 https://github.com/traceroot-ai/traceroot

💬 Summary

Hey Xinwei and Zecheng here, we are the authors of TraceRoot (https://github.com/traceroot-ai/traceroot).

TraceRoot (https://traceroot.ai) is an open-source debugging platform that helps engineers fix production issues faster by combining structured traces, logs, source code contexts and discussions in Github PRs, issues and Slack channels, etc. with AI Agents.

At the heart are our lightweight Python (https://github.com/traceroot-ai/traceroot-sdk) and TypeScript (https://github.com/traceroot-ai/traceroot-sdk-ts) SDKs - they can hook into your app using OpenTelemetry and captures logs and traces. These are either sent to a local Jaeger (https://www.jaegertracing.io/) + SQLite backend or to our cloud backend, where we correlate them into a single view. From there, our custom agent takes over.

The agent builds a heterogeneous execution tree that merges spans, logs, and GitHub context into one internal structure. This allows it to model the control and data flow of a request across services. It then uses LLMs to reason over this tree - pruning irrelevant branches, surfacing anomalous spans, and identifying likely root causes. You can ask questions like “what caused this timeout?” or “summarize the errors in these 3 spans”, and it can trace the failure back to a specific commit, summarize the chain of events, or even propose a fix via a draft PR.

We also built a debugging UI that ties everything together - you explore traces visually, pick spans of interest, and get AI-assisted insights with full context: logs, timings, metadata, and surrounding code. Unlike most tools, TraceRoot stores long-term debugging history and builds structured context for each company - something we haven’t seen many others do in this space.

What’s live today:

- Python and TypeScript SDKs for structured logs and traces.

- AI summaries, GitHub issue generation, and PR creation.

- Debugging UI that ties everything together

TraceRoot is MIT licensed and easy to self-host (via Docker). We support both local mode (Jaeger + SQLite) and cloud mode. Inspired by OSS projects like PostHog and Supabase - core is free, enterprise features like agent mode multi-tenant and slack integration are paid.

If you find it interesting, you can see a demo video here: https://www.youtube.com/watch?v=nb-D3LM0sJM

We’d love you to try TraceRoot (https://traceroot.ai) and share any feedback. If you're interested, our code is available here: https://github.com/traceroot-ai/traceroot. If we don’t have something, let us know and we’d be happy to build it for you. We look forward to your comments!

🗣️ Post 3: Show HN: Kanban-style Phase Board: plan → execute → verify → commit

As posted by: pranshu54  |  🔥 Points: 5

🔗 https://traycer.ai/

💬 Summary

After months of feedback from devs juggling multiple chat tools just to break big tasks into smaller steps, we re‑imagined our workflow as a Kanban‑style Phase Board right inside your favourite IDE. The new Phase mode turns any large task into a clean sequence of PR‑sized phases you can review and commit one by one.

How it works

1. Describe the goal (Task Query) – In Phase mode, type a concise description of what you want to build or change. Example: “Add rate‑limit middleware and expose a /metrics endpoint.” Traycer treats this as the parent task.

2. Clarify intent (AI follow‑up) – Traycer may ask one or two quick questions (constraints, coding style). Answer them so the scope is crystal‑clear.

3. Auto‑generate the Phase Board – Traycer breaks the task into a sequential list of PR‑sized phases you can reorder, edit, or delete.

4. Open a phase & generate its plan – get a detailed file‑level plan: which files, functions, symbols, and tests will be touched.

5. Handoff to your coding agent – Hit Execute to send that plan straight to Cursor, Claude Code, or any agent you prefer.

6. Verify the diff – When your agent finishes, Traycer compares the diff to the plan and checks compatibility with upcoming phases, flagging any mismatches.

7. Review & commit (or tweak) – Approve and commit the phase, or adjust the plan and rerun. Then move on to the next phase.

Why it helps?

* True PR checkpoints – every phase is small enough to reason about and ship.

* No runaway prompts – only the active phase is in context, so tokens stay low and results stay focused.

* Tool-agnostic – Traycer plans and verifies; your coding agent writes code.

* Fast course-correction – if something feels off, just edit that phase and re-run.

Try it out & share feedback

Install the Traycer extension (https://traycer.ai/installation), create a new task, and the Phase Board will appear. Add a few phases, run one through, and see how the PR‑sized checkpoints feel in practice. If you have suggestions that could make the flow smoother, drop them in the comments - every bit of feedback helps.

🗣️ Post 4: Show HN: Valitron – I built an AI that interviews and ranks job applicants

As posted by: valitron  |  🔥 Points: 2

🔗 https://news.ycombinator.com/item?id=44765504

💬 Summary

Hi HN,

We're trying to address a pressing problem expressed by recruiters. Candidates can now use AI tools to brute force hundreds of job applications, all tailored at scale, causing what's now being referred to as "the application avalanche". LinkedIn reported a 45% increase in applications this year alone. Recruiters are increasingly overwhelmed by this tidal wave - making it nearly impossible to know who is actually qualified. As a result, many companies are becoming reluctant to post open roles and instead rely on warm intros or internal referrals.

We built Valitron, an AI interviewer that talks to every applicant simultaneously, asks adaptive follow-up questions (not just a static script), and then ranks candidates by job suitability. It’s prompted to follow validated behavioral and competency interviewing frameworks, so it digs deeper into real skills rather than accepting rehearsed or vague answers.

Here is a demo: https://www.youtube.com/watch?v=WpCnjD7eg4Q

Unlike existing tools that just collect recorded answers for human review, Valitron both conducts the interview and scores candidates objectively. Recruiters end up spending time only with the best applicants, reducing time-to-hire from weeks to days.

We’d love feedback from the HN community on the product, the approach, and potential concerns or edge cases.

Website: https://www.valitron.ai

🗣️ Post 5: Show HN: Tambo – a tool for building generative UI React apps with tools/MCP

As posted by: milst  |  🔥 Points: 2

🔗 https://github.com/tambo-ai/tambo

💬 Summary

Hey!

We're working on a React SDK + API to make it simple to build apps with natural language interfaces, where AI can interact with the components on screen on behalf of the user.

The basic setup is: Register your react components, tools, and MCP servers, and a way for users to send messages to Tambo, and let Tambo respond with text or components, calling tools when needed.

Use it to build chat apps, copilots, or completely custom AI UX.

The goal is to provide simple interfaces for common AI app features so we don't have to build them from scratch. Things like:

- thread storage/management

- streaming props into generated components

- MCP and custom tool integration

- passing component state to AI

plus some pre-built UI components to get started.

Would love feedback or contributions!

🎯 Final Takeaways

These discussions reveal how developers think about emerging AI trends, tool usage, and practical innovation. Take inspiration from these community insights to level up your own development or prompt workflows.