I m working on an AI system designed to close the loop in scientific research.

The problem I kept running into during my PhD in chemistry:
Scientific research is still very manual: humans design experiments, write protocols, run them, analyze results, and decide what to do next. This makes iteration slow and expensive.

Hey PH folks

I ve been doing some vibe coding lately and ended up building Cursor Pet a small browser extension where a pixel-art pet follows your mouse and idles when you stop.

It started as a fun side project, but it got me thinking about micro-delight in everyday tools. Sometimes small, playful elements can make long browsing or coding sessions feel lighter.

I d love your thoughts on:

"Wellness app that respects your time"

https://ugoki.uk/

This is my first post ahead of launching CureMyCar on 5 January.

Before building CureMyCar, I ran an alloy refurbishment business and regularly outsourced other automotive services for customers. That experience exposed a much bigger problem than just fixing wheels.

Customers constantly asked:

• What s actually wrong with my car?

• Am I being charged fairly?

• Who can I trust to do the work?

Hey everybody! Happy New Year! @Climate Savers is now live on Product Hunt. We are building a social-fintech platform to help you save money and get rewarded for living sustainably, giving you climate agency by empowering you to vote with your money.

https://app.climatesavers.io/car...

Hey everyone,

I started building a side project that s been keeping me sane and inspired.

It s a URL management and link tracker, but not just another Bitly or TinyURL clone. I wanted to create something more powerful from the start, a tool that gives users full access to analytics and insights without the usual paywalls or ads. I also want to use AI analysis on the data to give users insight into the which day should they market based on historical data and also have cybersecurity features so that adult content and malicious links are not shared.

Here s what it offers so far:

I ve worked with a few small businesses and solo founders, and I keep noticing the same thing.

Everyone knows software updates matter.
But in reality, most small teams don t have:

• a dedicated security person

• time to read technical security alerts

• budget for enterprise security tools

• patience for complex setups or constant monitoring

So software security usually looks like this:

TL;DR: I built a platform to validate a hypothesis: If we lower the barrier to entry for using and productizing agents, will normal users actually like them? I m looking for builders to test it out. You can take your existing agent code, fill out a simple manifest, run a few CLI commands, and have a shareable, web-accessible agent in 10 minutes. Links at the bottom.

Happy New Year, everyone.

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.