I thought to myself "what if there was a game that took the fun of a picture game like Pokemon Snap (but catching pics of PEOPLE instead of Pokemon) and combined it with the Location Tracking aspect of Pokemon Go?" And so I started making ZnapZor, which honestly is not really like either of those games but is nonetheless addictive, mindless and FUN.

The premise is you're a Zor alien now on Earth to gather data (images) of earthlings doing earth things in as many habitats as possible. You take Znapshots of people and the more interesting the actions and locations the higher the score. The images are "translated" into ZorCode and highest scoring go on the Leaderboard.

I've been working on building it and letting my friends test it and I knew I was on to something when every day tons of new pics started appearing. I was no longer having to ask them to test it-they couldn't stop playing around and taking Znaps all day. Still some work to do but releasing it SOON. wanna play?

Hi Everyone!

I m a student and developer, and I noticed that I spend 20% of my time writing reports and 80% of my time fighting with margins, font sizes, and alignment.

To fix this, I m building a web app called DraftFlow. I d love your feedback on the core workflow:

1. Raw Input: You just dump your raw, messy text into the app.

2. Auto-Canvas: The app switches to a "Canvas Mode" and automatically applies the correct styles (headings, paragraphs, title) based on the document type (e.g., Report vs. Article).

3. Split Screen AI: On one side, you have your styled doc. On the other, a Multi-Agent Chatbot that helps with grammar, tone, and suggestions without messing up your layout.

4. Done: One-click download to a perfectly formatted PDF.

I need your help with two questions:

1. Trust vs. Control: Is "auto-formatting" something you would trust for a final document, or do you prefer manual control over every pixel? I'm trying to decide how much editing power to give the user vs. keeping it fully automated.

2. The Idea: Please be honest is this tool actually needed? Is the pain of formatting documents big enough that you would switch to a tool like this?

   Thank you for reading

Stop guessing. Start seeing what actually kills your MRR.

Hey Product Hunt!
I m a solo founder who kept running into the same painful question:

Why are users signing up clicking around and then disappearing forever?

From SaaS to Personal Portfolios I bring your ideas to life with pixel-perfect websites.

Hey Product Hunt fam

I'm Shaswat Raj, a solo indie dev and designer who loves turning ideas into fast, beautiful, and responsive landing pages.

Hi everyone I m Mia.

I m working on Cleanor, an iOS utility, on on-device cleanup and indexing.

Both the website and the app are still in development.

Current stack: iOS, SwiftUI, SQL, on-device AI.

Over the last couple of years, I ve felt the same frustration a lot of AI builders feel:
LLMs are powerful, but they don t really know who they re talking to.
Every conversation starts from scratch. Your AI assistant forgets user preferences like please keep answers short , it forgets what you discussed last week, and it can t reliably recall that the person on the other side is an experienced dev at a startup, not a beginner.
We have incredible models, but when it comes to long-term interaction with a human, they re basically goldfish.
Today, I m excited to share something I ve been building to fix that:
GetProfile is now open source a drop-in LLM proxy that gives your AI agents user profiles and long-term memory.
It s Apache-2.0 licensed, self-hostable, and designed to slot into existing OpenAI-style stacks with minimal changes.
Why another memory layer ?
A lot of smart people are already working on AI memory.
Projects like Mem0 describe themselves as a universal memory layer for AI agents , focused on storing and retrieving user interactions so assistants can remember preferences and context over time.
Supermemory pitches a scalable plug-and-play memory infrastructure and a Memory OS for AI apps, with APIs, SDKs and a Memory Router to attach persistent memory to any stack.
I love that this space exists. But I also kept noticing a missing piece in my own projects:
Most memory solutions are great at storing facts and messages.
What I wanted was a way to maintain an evolving user profile.
Not just everything they ever said , but:
- What s this user s communication style?
- How advanced are they in this domain?
- What are their stable preferences?
- What events in their history actually matter?
In other words: I wanted something that looked less like a blob of text and more like a structured, typed profile that evolves over time.
So I pivoted GetProfile AI to become exactly that.
From profiling API to LLM proxy with memory
GetProfile originally started as an AI-powered profiling API: send it raw data (chat logs, onboarding forms, CRM records, game events) and it would return structured profile information and summaries you could plug into your existing tools.
That was useful, but the more I talked to indie hackers and founders building agents, the clearer one thing became:
They didn t just want profiles over there in some API .
They wanted their AI agents to "actively use" those profiles in every conversation.
So I rebuilt GetProfile as an LLM proxy and made it open source.
Now the flow looks like this:
1. Your app or agent sends a normal OpenAI-style request but to the GetProfile proxy.
2. GetProfile loads the user s profile and relevant memories from its database.
3. It injects a compact profile summary, traits, and selected memories into the prompt as a system message.
4. It forwards the enriched request to your actual LLM provider (OpenAI, Anthropic, OpenRouter, etc.).
5. It streams the response back to you.
6. In the background, it analyses the interaction, extracts new traits and memories, and updates the user profile.
From your agent s perspective, it s still just OpenAI . Under the hood, it now has a brain that actually remembers who it s talking to.
What GetProfile actually does
At a high level, GetProfile does four things for you:
1. Captures
It receives conversations between your users and your AI via an OpenAI-compatible chat completions API.
2. Extracts
It uses LLM analysis to extract structured traits (like expertise level, tone preference, interests) and important memories (events, milestones, recurring topics) from those interactions, and associates them with a user profile.
3. Injects
For every future request tagged with the same profile ID, it injects a system message that includes a short profile summary, typed traits, and a small set of relevant memories.
4. Updates
It keeps the profile evolving over time: traits can grow more confident or be overwritten, memories can be summarized and pruned, and the profile stays in sync with how the user actually behaves.
The key difference from many other solutions is that the profile is structured.
Instead of storing raw text blobs, GetProfile turns user understanding into typed fields with confidence scores and importance levels, backed by a PostgreSQL schema you can inspect, query, and integrate with the rest of your stack.
For example, a profile might look like this (simplified):
Summary:
Alex is an experienced software engineer who prefers concise, technical explanations. They mostly work in Python and have been exploring distributed systems lately.
Traits (with confidence):
`expertise_level`: `advanced` (0.8)
`communication_style`: `technical` (0.7)
`interests`: `["Python", "distributed systems", "ML"]` (0.6)
Memories (with importance):
Mentioned working on a microservices migration last week.
Prefers async/await over callbacks.
This makes both extraction and injection first-class citizens.
You can customize what gets extracted and how it s injected
One of the core design decisions in GetProfile is that you shouldn t be locked into my idea of what a user profile is.
Instead:
- Profiles live in a generic, extensible schema.
- Traits are configured in JSON files you control.
- Each trait can have its own extraction and injection behavior.
For example, you might define a trait like `travel_preferences` with:
- value type: `array` of strings,
- extraction prompt snippet: Extract the user s travel style preferences from the conversation.
- injection template: User prefers: {{value}}.
GetProfile will then:
1. Extract this trait from interactions where it s relevant.
2. Store it alongside other profile data.
3. Inject it into prompts when it matters.
You can keep things minimal (just a couple of traits), or build a rich personality/intent schema for your agents.
Why open source?
There are a few reasons I decided to ship this as open source:
1. Trust and transparency
Memory and profiles are sensitive. If you re going to let an external service sit in the middle of all your LLM traffic, you need to know what it does. With GetProfile, you can read the code, run it on your own infrastructure, and audit the entire data flow.
2. Self-hosting as a first-class option
GetProfile is meant to be deployed in your environment:
Lightweight proxy built with Hono
Persistent storage in PostgreSQL
Docker-based deployment for easy scaling with Compose or your orchestration of choice
3. Community and experimentation
I don t believe there will be a single correct way to do AI memory or profiling. Different apps will want different traits, models, heuristics, and architectures. By open-sourcing the engine, I m hoping other builders can extend it, plug it into their agents, and help explore what good user memory actually looks like in practice.
4. A sustainable path to a cloud version
On top of the open-source core, I m planning a managed GetProfile Cloud for teams that don t want to self-host. The open-source and cloud versions will share the same engine, but the cloud will add things like a hosted dashboard, usage tracking, multi-tenant management, and batteries-included scaling. You can already join the waitlist from the main site.
Who is GetProfile for?
In its current MVP form, GetProfile is already useful if you re:
- Building an AI assistant or agent and you want it to remember user preferences and personality over time, not just the current thread.
- Running a customer support bot that needs to adapt to plan tier, frustration level, tone preference, and past issues.
- Designing an AI tutor or coach that should build a picture of the learner and tailor explanations over weeks or months.
- Creating a game with AI-driven NPCs or systems that react to player behavior and evolving player profiles .
If your stack speaks OpenAI , you can integrate it just by changing your base URL and adding a couple of headers for profile IDs and upstream provider keys.
What s inside the MVP today
Right now, the OSS MVP includes:
- An OpenAI-compatible proxy with streaming support.
- A PostgreSQL-backed profile + memory store.
- Configurable trait schemas and prompts via JSON.
- Automatic extraction of summaries, traits, and memories from conversations.
- Automatic injection of profile + memories into prompts as a system message.
- Docker setup for easy deployment.
- A growing set of docs covering concepts, quickstart, configuration, and the JavaScript/TypeScript SDK.
It s early. There are a lot of features I want to add: more granular control over what gets injected, better memory summarization, richer analytics, integrations into other ecosystems, and more.
But the core loop capture extract inject update is already working.
How to try it
If you want to play with it:
1. Visit https://getprofile.org for the overview and docs.
2. Clone the repo from GitHub and start it with Docker.
3. Point your existing OpenAI client at the GetProfile proxy and set `X-GetProfile-Id` to whatever user identifier you re using.
If you like what this is trying to do, a star on GitHub or a tiny comment about your use case would mean a lot.
I d also love to hear from you if you re:
- Building agent frameworks or orchestration tools.
- Working on long-term AI products (co-pilots, tutors, assistants, games).
- Interested in experimenting with different trait schemas and profiling strategies.
GetProfile is still small and early, but I think user profiles and long-term memory for AI agents is a layer that needs to exist in the open not just as a closed black box.
If that resonates, come hack on it with me.

Tired of AI agents hallucinating fake emails & domains in your leads?

AIvetted gives independent, deterministic verification + shareable PDF reports to catch issues before clients see them.

Quick try (no signup): https://aivetted.fly.dev/

I built a product that takes some time to get used to before it starts bringing real value. It's not easy, but I'm trying to slightly change how people think.
Why?

The thing is, with the rise of AI chats, we've started thinking on our own much less. We make fewer independent decisions and come up with fewer ideas. The parts of the brain responsible for critical thinking simply stop working.

Think about it - when was the last time you fully thought through your own idea without ChatGPT?

The Tax Talk: Live with a CPA

THU, December 18 @ 11.00 am EST / 08.00 am PT

Free

Building a new tool called Doccier, designed for solo developers and small teams who want to focus heavily on building their product rather than creating all the material around it.
Here's what it does:
Doccier connects to your codebase, analyzes it, and forms an understanding of your product. It creates the documentation and visual guidelines. Then, whenever you make a commit, Doccier automatically generates:
- a clean summary of what changed
- short release / update posts
- polished visuals or simple graphics for sharing
- ready-to-post announcements for socials
- internal documentation updates
- organized changelogs
Instead of doing everything manually or jumping between different AI tools to explain your product again and again, Doccier produces these directly from your code.
If this is something you'd find helpful, early access is open:
doccier.com