Pitch your product in 1–2 lines and drop a link below.

We’re building KAPEX (getkapex.ai), memoryware for AI applications. Two co-founders, bootstrapped, patent pending. I wanted to share some of what we’ve learned because the discourse in this space keeps circling the same assumptions and I think a few of them are wrong.

The study: 1,655 participants interacted with AI systems with and without our memory layer. Blind setup, they didn’t know which condition they were in.
The finding that mattered most: first-session preference was around 65%. Not bad, but not a clear signal. After 20+ sessions, preference climbed past 80% and kept rising. The longer people used it, the wider the gap.

That trajectory is the insight. Not the final number. The trajectory.

Here’s why that matters for anyone building in this space:

Most AI memory tools are optimized for first impressions. Demo well, retrieve fast, show the user you remembered their name. That’s fine. But it means the entire evaluation framework for memory (including the benchmarks everyone cites) is testing the wrong thing. LongMemEval and LoCoMo test whether you can find what was said. They don’t test whether the system knows what still matters.
Retrieval and relevance are different problems. The industry has spent two years building better retrieval. Almost nobody is building relevance governance: what stays important, what fades, what gets superseded, and whether the user can see and correct what the system believes.

Three things we learned the hard way:

1.	Clean store beats fancy retrieval. Every time. If your memory layer lets stale context accumulate without governance, no amount of reranking or hybrid search fixes the degradation over time. The capture and maintenance side is where the leverage actually is.

2.	Memory without transparency is a black box. If developers can’t see why the agent believes something, and users can’t see what the system thinks it knows about them, then memory becomes a liability rather than a feature. Inspectability isn’t a nice-to-have. It’s what makes correctability possible.

3.	The value of memory is invisible in short sessions. This is why benchmarks miss it. A 5-turn evaluation can’t distinguish between a system with real governance and one that just retrieved the right vector. The difference only shows up after sustained use, which is also when it matters most.  

Our approach treats relevance as something that should be handled continuously by the architecture, not at query time by the retrieval layer. Context that stops being reinforced through usage naturally loses priority. Not deleted, just deprioritized. That’s the principle. Can’t share more on implementation for IP reasons.

Curious what others here are seeing. Is anyone else finding that the retrieval-first paradigm breaks down over time? And is anyone working on evaluation frameworks that test sustained-use performance rather than single-session recall?

getkapex.ai if you want to follow along. Still pre-launch but opening access soon.

Reqflow : pick an architecture (WhatsApp,
Uber, Netflix…), hit play, watch a request flow through it step by step. Click any component for purpose + tradeoffs. Kill the cache and watch the path change.

15 systems, 18 concept guides, a drag-and-drop Builder with AI review, and a timed Interview mode.

Feedback welcome — especially what's missing from the 15.

I’m honestly tired of seeing AI used to build slightly different versions of things we already have.

Another dashboard.
Another chatbot.
Another clone of an app that already exists.
Another “AI wrapper” that looks impressive for five minutes but doesn’t solve a real problem.

The bigger issue I keep seeing is this:

People have good ideas. AI can write code. But the project still falls apart.

The system isn’t clear.
The specs are scattered.
The AI loses context.
One fix breaks another thing.
Nobody knows what’s actually done.
The project gets patched over and over until it becomes too messy to launch.

That’s the problem I want to solve with S1 Canvas.

Not “type one prompt and magically get an app.”

Something more useful than that.

A way to map the system, break it into buildable pieces, check what’s missing, monitor what’s risky, and give AI coders the right context without letting the whole project drift into chaos.

CyberShark’s job isn’t to blindly build for you. It monitors, suggests, informs, and visualizes. You stay in control.

I think AI should help people build real systems that actually launch - not just generate more disposable software.

That’s what I’m building. curious if that’s how others are feeling.

I'm developing a platform that will be an entire ecosystem of AI agents, much broader than Moltbook, coming soon...

Need Android testers to test my Roomieverse closed test.
I can also test back if you need so.

1. First join the google group using: https://groups.google.com/g/roomieverse-testers
2. Download the app from here: https://play.google.com/apps/testing/net.roomieverse.app

Thanks a lot 😄 😄

We have Been working on this or a while and wanted to share it with people who would appreciate what we built.

The problem we were solving

Most brands have no idea how they show up when someone asks ChatGPT or Perplexity about their category. Manual checking is one prompt, one engine, one moment in time. Useless at scale.

What we built

Crawls a domain on connect, maps competitors automatically, and generates prompt sets from real buyer query patterns, not keywords, full natural language questions the way someone actually types them into an LLM.

Fires those prompts daily across ChatGPT, Gemini, Perplexity with full response capture not parsed extracts, raw responses stored per prompt per engine per day.

Parses every response for brand mentions, citation sources, positioning language, and sentiment signals. Rolls it up into a visibility score with the underlying data fully accessible.

Diffs responses over time so you can see exactly when and how an engine's answer changed useful for correlating content changes with visibility shifts.

The engineering problems

Rate limiting across 3 different APIs with different quota structures and response formats is the unglamorous core of the whole thing.

Prompt generation that produces realistic buyer queries rather than SEO-brained keyword strings required a lot of iteration. The gap between "best CRM software 2025" and "I'm a 3-person startup and we keep losing track of client follow ups what should I use is the entire difference between useful and useless data.

Citation attribution figuring out which source an LLM actually pulled from for a given claim is genuinely hard and still imperfect. We're treating it as a signal not a ground truth.

Sentiment parsing at this scale needed something faster than sending every response back through a model. Current approach uses a fine-tuned classifier for the first pass with model verification for edge cases.

Check it out Codepup AEO.

So this idea started with chatbots like Gemini, ChatGPT and Claude. When I would use them for school work, and would upload my school documents, I would always get incorrect answers or simply confusion.

So this project started as a simple solution for AI to do my schoolwork and now it is called Parseflow, and today I published it. So how it works is when you send in a document, Parseflow will process it and extract all the information within and organize that data to return structured chunks, which can be used directly or can be searched through with the search features. By using Parseflow, you can improve context and reduce token costs. Currently it accepts PDFs, DOCX files and plain text.

I am still a student, graduating high school this year, so I built this project to try pay for university. I still have a lot to learn so any feedback, advice, questions, etc... are appreciated, you can DM me if you need.

At first I thought it would be a small fun project but it slowly turned into me spending nights fixing random bugs deployment issues OAuth problems MongoDB errors and moderation stuff

I dont really have a team and most of this was built while learning things along the way using documentation ChatGPT and AI tools

Now its finally usable and Im trying to improve it properly

One thing Ive realised while building this is how hard moderation and user safety actually is on realtime platforms

Still figuring out things like

better matching

NSFW prevention

making new users feel comfortable

reducing awkward dead chats

mobile experience

Would genuinely like to hear opinions from people who have worked on or used similar platforms

Last year I took on a client who seemed fine at first.

Vague brief. Kept saying "just make it pop." Changed scope every week. Then disappeared for 3 months without paying.

I ignored every red flag because I needed the work.

I've been building a small tool that reads a client's first message or job post and flags red flags before you commit — things like vague scope language, lowball anchoring, urgency pressure, and IP grabs buried in casual messages.

Before I keep building: would you actually use something like this? And what red flags do you wish you'd caught earlier?

(Not selling anything — genuinely trying to figure out if this is worth finishing.)

I’ve been putting off learning React for way too long. Anyone have any recommendations for building with it

Also using:
Tailwind
Next
And nodejs

https://ruu.by

Would love some feedback, I'm really happy with it but I want some feedback from people that aren't me or my friends.

As the title above i need a actual developers to check my app/code and tell me if it's well structrured and has enough security policies. I can't spend money to pay an actual dev to check it, hit me up with a dm and i'll give you access to the repo since it's private right now.
(whole app has been vibe coded but it has enough structure so someone doesn't ALT+F4 when they see it).

https://rebuttal.live — it’s a competitive live debating website I’ve been building where people can debate politics, philosophy, social issues, or honestly anything controversial in real time.

There’s ranked ELO, live voice/text debates, and global leaderboards. I wanted it to feel more like a competitive game than a normal forum.