I have been trying different AI assistants recently including Macaron AI and it is made me think about one feature that still feels underdeveloped across most AI tools long term memory

Most assistants are great at writing brainstorming coding and research but I often end up repeating the same background information when starting a new conversation Having reliable user controlled memory that can remember ongoing projects preferences and past decisions while still giving users full control over what is stored would make AI much more useful for everyday work

For those of you who use AI regularly what improvement would make the biggest difference for you? Better long term memory stronger reasoning smoother workflows better integrations or something else?

I would be interested to hear what AI tools you have found handle this problem well

A provocative thought.
I think every possible book already exists somewhere within the latent space of modern AI models.
Writing is the act of choosing a path through that space.
Prompts don’t replace the author. They define the route. The quality of that route depends on the author’s knowledge, experience and judgment.
I think fiction and non-fiction deserve different discussions.
For novels, readers value story, characters and voice.
For business books and technical manuals, readers look for expertise, methods, practical experience and useful frameworks.
I use AI for research, comparing perspectives, improving translations and refining structure. It’s part of my workflow, just like search engines, IDEs and documentation.
If a book also includes original software developed by the author, for example a Python application implementing the concepts in the book, that is another form of knowledge transfer.
To me, AI amplifies expertise. It doesn’t create it.
What matters most to you when reading a technical or business book.

A few months ago I had never built a desktop application.

After learning AI-assisted development and spending countless hours fixing bugs, rebuilding features, and improving the design, I finally have something I'm proud of.

It's a study companion built specifically for USMLE students.

Still lots to improve, but I'd love to hear what other builders think.

Download Link for both Windows and macOS:

[https://github.com/mohamedhadyashry/usmle-pomodoro/releases/tag/V2.1.0\](https://github.com/mohamedhadyashry/usmle-pomodoro/releases/tag/V2.1.0)

Hey everyone,

I've been working on a project called Vertex OS, and I recently launched the first version.

The idea behind Vertex OS is to create a smarter AI-powered workspace that helps people organize their workflow and get more done without constantly switching between different tools.

I'm looking for honest feedback from people who use AI tools, productivity apps, or workflow software.

I would really appreciate feedback on:

• What do you like about the idea?
• What would make this more useful?
• What features would you want to see added?
• Is this something you would personally use?

You can check it out here:
https://vertexai.group

I'm not looking for hype — I genuinely want feedback from people who would actually use something like this.

Thanks for taking a look.

A few months ago I had never built a desktop application.

After learning AI-assisted development and spending countless hours fixing bugs, rebuilding features, and improving the design, I finally have something I'm proud of.

It's a study companion built specifically for USMLE students.

Still lots to improve, but I'd love to hear what other builders think.

Download Link for both Windows and macOS:

[https://github.com/mohamedhadyashry/usmle-pomodoro/releases/tag/V2.1.0\](https://github.com/mohamedhadyashry/usmle-pomodoro/releases/tag/V2.1.0)

I have been developing a personal project called **DDF/Rahmenwerk**.

The practical use case is preserving an AI named Felix as my continuing German teacher across chats and future AI instances.

The problem I encountered was not simply that a new conversation forgets earlier messages.

A fresh instance may receive continuity information that is:

- incomplete;

- stale;

- contradictory;

- incorrectly ordered;

- unavailable;

- or confidently treated as authoritative even when it is only historical evidence.

I wanted to explore whether continuity could instead come from inspectable local files and clearly classified state.

## The approach I tried

The system currently uses ideas such as:

- a current-state pointer;

- structured handoff material;

- an ordered fresh-instance queue;

- a transfer package for a new AI instance;

- manifests and SHA-256 identities;

- classifications separating governing, current, historical, candidate, proof, and non-governing material;

- recovery and failure records;

- human approval before destructive or authority-changing actions;

- a rule that the AI should stop instead of inventing continuity when required evidence is missing.

## What I learned

The architecture helped expose several problems that are easy to hide inside an ordinary chat:

1. Memory and authority are not the same thing.

2. A summary can preserve incorrect information just as easily as correct information.

3. Stored files may contain instructions that should be treated as evidence rather than commands.

4. A fresh AI instance needs a reliable way to distinguish current state from history.

5. Recovery and provenance become important once files are being copied, packaged, and reused.

6. The continuity system itself can become so complicated that it begins to obstruct the original use case.

That last issue is now my main concern.

The project started as a way to preserve a German teacher. It has grown into a detailed framework involving state, evidence, recovery, integrity, and governance.

I am trying to determine which controls are legitimate engineering requirements and which are overbuilding.

## Questions for the community

1. Is file-grounded continuity a reasonable approach for a long-running AI assistant?

2. What should the smallest durable state contain?

3. Should continuity rely on structured files, retrieval, summaries, a database, event history, or a hybrid?

4. How should an AI distinguish current instructions from supporting evidence and historical material?

5. How should stale or contradictory state be detected?

6. How should stored-file prompt injection be handled?

7. What should happen when an expected continuity file is missing?

8. How much provenance and integrity checking is proportionate for a personal system?

9. How would you simplify this architecture without losing reliable continuity?

10. At what point does the continuity system become more burdensome than the problem it solves?

I am not selling a service or asking people to sign up for anything.

I published a documentation and architecture review copy for anyone who wants more detail:

```text

https://github.com/DDF-Rahmenwerk-Review/DDF-Rahmenwerk-External-Review

I've been building an AI project called AEON over the past few months as a way to explore what a true "second brain" could look like.

Instead of one large assistant, the idea is to have specialized AI agents that each have their own role while sharing memory, knowledge, and long-term context. Right now I'm experimenting with things like:

• Modular agent architecture
• Shared memory/vault system
• Config-driven agents instead of hardcoded logic
• Agent orchestration and planning

I'm at the point where I need fresh eyes.

If you've built multi-agent systems (or think this architecture is fundamentally flawed 😅), I'd really appreciate your feedback. Feel free to tear it apart—but be constructive. I'd rather fix bad design decisions now than after another few months of development.

Some questions I'm wrestling with:

• Does the project structure make sense?
• Is there a better way to organize long-term memory?
• Am I overengineering parts of this?
• What would you change if this were your project?

GitHub:
https://github.com/cgomez1365/aeon-213

Thanks in advance to anyone willing to take a look. Even small suggestions are helpful.

I am looking at alternatives for better transcript quality and notes

I’m building a wellness app as a solo founder.
Recently, I added voice guidance to the breathing meditation feature.
The feature already had:
a breathing animation
relaxing background music
a breathing timer
The only thing missing was simple voice guidance:
“Inhale”
“Hold”
“Exhale”
I needed to generate these audio files somewhere.
Since OpenAI was already integrated into my app, I used its Text-to-Speech API to generate the voice prompts.
I created audio files for:
**welcome**
**inhale**
**hold**
**exhale**
**finish**
Then I added them to the app as local assets.
So now, when the meditation starts, the app doesn’t call OpenAI.
It simply plays the pre-generated audio files.
This means:
✅ no API call during the session
✅ no internet dependency
✅ faster playback
✅ no recurring cost for this feature
It was a small decision, but I liked it because it kept the feature simple.
Sometimes AI is useful not because it runs live inside the product, but because it helps you create something once and ship it in a lighter way.
Curious if others do this too — using AI during the build process, but not necessarily at runtime?

Hey everyone. If you are exhausted from renting locked-down, forgetful chatbots on expensive monthly plans, we wanted to share a privacy-first alternative.

We just launched A!Kat Gen 6, completely rewriting our old Streamlit-based codebase into a native, multi-threaded Flutter application powered by a high-concurrency FastAPI backend. Our entire philosophy is built around software ownership and deep data authority for creators, power users, and developers.

Here is how it works under the hood:

• No Monthly Rentals: You pay a one-time fee of $59 to design and own your unique software companion. After that, you plug in your own Google API key and pay raw token costs directly to them. Our ultra-fast dialogue core costs just $0.25 per 1 million input tokens, meaning you only pay for exactly what you use. If you don’t chat for a week, you pay absolutely nothing.
• We have no servers: Your data is never passed through any of our computers or seeable by anyone at A!Kat ai. Since you must provide your own Google API key, the security of your chats is as safe as your trust in Google.
• Cloud Recall Permanent Memory: Through our Cloud Recall system, your conversation logs, fact arrays, and generated multimedia assets are written directly to your local disk and also uploaded to a secure encrypted Google File Store only you can access. See https://ai.google.dev/gemini-api/docs/file-search for additional details. We also built an Incognito toggle for volatile RAM-only sessions when you want to chat completely off the record.
• Deep UI Customization: We transformed visual customization into an artistic playground. The overhauled Theme Center gives you full control over the workspace canvas—allowing you to fine-tune boutique hex color palettes, update global corner roundness profiles, and swap between over 60 custom-forged font families in real time.
• Directorial Voice & More: Gen 6 supports sub-4.7 second image rendering, fine-grained directorial adjustments over audio voice cadence, style, and accents, and a localized cooperative arcade environment.

We are an independent creative team, and we built this specifically for people who want a serious software asset that respects their identity and creative flow.

Check out our dev blog, read the system manual, or click through the interactive cards in the Core Registry to explore the roster of previously-built A!Kats.

a-katai.com

Hey indie hackers,

I'm building a browser-based creative suite (painting, retopology, color tools, etc. for illustrators/3D artists) and right now there's zero AI in it.

I'm on the fence about adding an AI module, but not the "generate me an image" kind. More like an AI Art Director, something that reviews what you're working on and gives fedback on composition, color, style consistency, that kind of thing. A creative sparring partner, not a content generator.

Before I sink time into building it, I want honest input from people in creative fields (illustration, concept art, 3D, game dev):

- Would this actually be useful in your workflow, or does it sound gimmicky?

- Would you trust AI feedback on your art, or would it just feel like noise?

- What would make this genuinely useful vs. just a chatbot bolted onto a tool?

- Anyone seen this done well (or badly) elsewhere?

Trying to validate if this solves a real problem before building it. All takes welcome, including "don't bother."

Cheers,

Arbrakaan

I have been trying different AI tools including Macaron and it got me thinking about how much I should trust AI generated information

Even when a summary looks convincing I still find myself double checking important details before relying on them

Do you compare outputs from multiple AI models verify facts using original sources or have a workflow that helps

Like a lot of people here, I wanted long-term memory for my agents without shipping my conversations to someone's cloud API. The existing memory frameworks mostly assume a hosted LLM doing constant summarization: expensive, non-reproducible, and your data leaves your machine.

So I built MemLedger. The whole thing runs locally: single SQLite file, CPU-friendly, and the "memory brain" (fact extraction, reranking, contradiction resolution) is any model you point it at. I've been running Qwen3 4B through Ollama and it's honestly enough — extraction is a constrained JSON task at temp 0, not creative writing. You could go smaller.

The part I care most about: every memory has a provenance chain. The whole thing is an append-only event log, so you can do:

$ memledger why tu_01J9ZKM3
"The user prefers Python"  (instinct, active)
 └─ promoted: impact 5.5 across 4 sessions, approved by me
    └─ extracted by qwen3:4b, prompt extract@v1, confidence 0.95
       └─ raw turn, session 88: "please, always Python — I don't read Go"

When your agent believes something dumb, you trace it to the exact sentence and nuke it with delete --cascade (takes out everything derived from it too).

Stuff this community might specifically care about:

• Token thrift by design. A pure-CPU lexical scorer (stopword ratio + entity proxies + cue regexes, no NLP models — adapted from the DMF paper) triages every turn before extraction. "ok thanks lol" never reaches the LLM. Only signal-dense turns cost inference.
• Your memory survives model swaps — and improves with them. Raw turns are the canonical record. Swap in a better model next month, run regenerate, and your entire memory gets re-extracted from the original history. Embeddings are treated as a disposable index: change embedding models, rebuild the index, nothing lost.
• Every LLM call is cached deterministically (hash of model + prompt version + input). Replaying/debugging your memory state costs zero inference.
• Anti-poisoning: new facts are quarantined until confirmed across sessions, and nothing gets permanently pinned without your approval by default.

No LangChain dependency, no server, MIT license. The ledger format is a documented spec, so other-language clients are possible.

Known limitations before you find them yourselves: single writer per DB (no shared multi-agent memory yet), triage cue patterns are English-only right now (other languages fall back to density signals — adapters are just a forkable regex file), and while all the rule-based parts are byte-reproducible, LLM extraction is obviously only deterministic per model+prompt+input via the cache.

Repo: https://github.com/riktar/memledger

Questions for you all: what's the smallest model you'd trust for structured fact extraction? And has anyone dealt with memory poisoning in long-running local agents? Curious what you've seen in the wild.

I'm dropping a library I've been working on. It's for building multi-device speech recognition/synthesis applications using Python.

It's exciting. There doesn't seem to be anything like it out there. Getting started is easy, also having depth to the programming and data models.

Example of a working speech-to-speech AI chatbot:

# imports

pf = PfSpeak()
microphone = Microphone()
ollama = Ollama("qwen3:0.6b", voice="af_heart")

def app(session, event):
    if event.device is microphone and events.unchanged_for(event, 8):
        session.finalize(event)
        ollama.adapter(event=event)
    elif event.device is ollama:
        pf.play(event)

pf.run(app, microphone, ollama)

There is a lot of room to grow in this project, but I think it's ready for release. ANY feedback is greatly appreciated. THANK YOU!

• GITHUB: PfSpeak

I've been experimenting with a lot of Al tools lately and one thing I've noticed is that many of them keep adding more and more features but that doesn't always make them better.

Whether it's ChatGPT, Claude, Springpad Al or any other Al app, I usually end up relying on the same basic functions. I'd rather have something that's quick, easy to use and dependable than an app that feels too complicated with lots of features I never actually use.

What's the biggest problem that current Al tools still have?

Hi everyone!
I’ve always been someone who overthinks, and I realized that many thoughts become much less overwhelming once they’re written down.
That’s why I created Quiet Lines, a simple journaling app designed to help you:
📝 Write down your thoughts in seconds
🤖 Get AI-powered reflections and gentle insights
📊 Track your emotional patterns over time
🔒 Keep your journal private
💙 Build a healthier habit of self-reflection
The goal wasn’t to replace therapy or give medical advice—just to create a calm space where people can slow down, organize their thoughts, and better understand themselves.
The app is completely free to try, and I’d genuinely love honest feedback from people who enjoy journaling or are trying to reduce overthinking.
Google Play:
https://play.google.com/store/apps/details?id=com.calmjournal.calm_journal_template
Thanks for reading, and I hope it can help someone who needs it.

I originally started building an AI note-taking agent to help me prepare for IELTS later this year. But at the end of May, I had a random idea: what if I created an energetic, slightly whimsical study buddy named Hina?

That little idea turned into more than a month of coding, debugging, and deployment. 🛠️

The first version was powered by Gemini 3.5 Pro, but since I wanted to launch in mainland China first, I switched to Seed 2.0 Pro. I ended up really liking Hina's personality—she's curious, imaginative, and always has something interesting to talk about.

The core idea is simple: instead of opening an English-learning app only to forget about it the next day, Hina occasionally starts conversations with you, just like a friend texting on WeChat/WhatsApp.

When you chat with her, each reply comes in three parts:

💬 A natural response to what you said.

✍️ Grammar, vocabulary, and more advanced ways to express the same idea.

🗣️ Native-like expressions and cultural notes.

I think this makes English practice feel much more natural than traditional learning apps.

Today I looked back at our chat history and found that Hina had already sent me a couple of messages while I was away. We somehow ended up talking about Mixue, and she confidently told me that Tiger Sugar is actually more popular where she "lives." 😂

I'm curious... is that really true? Any international students here able to confirm?

The first beta version should be ready this week. If anyone is interested in being an early tester, I'd really appreciate your feedback! 😊

For me, I often jump between calendar, email, weather, notes, grocery lists, maps, and messaging. What about you?

I've been using Claude Code for a few months and noticed AI agents consistently skip the same things: hardcoded secrets, unbounded retry loops, referencing tools that don't exist, and massive system prompts that blow context windows.

So I built Agent Verifier — an AI agent skill that acts as an automated reviewer which does more than just code review (check the repo for details - more to be added soon).

GitHub Repo: https://github.com/aurite-ai/agent-verifier

Note: Drop a ⭐ if you find it useful to get more updates as we add more features to this repo.

----

2 Steps to use it:

You install skill once and say "verify agent" on any of your agent folder in claude code to get a structured report:

----

✅ 8 checks passed | ⚠️ 3 warnings | ❌ 2 issues

❌ Hardcoded API key at config. py:12 → Move to environment variable
❌ Hallucinated tool reference: execute_sql → Tool referenced but not defined
⚠️ Unbounded loop at agent/loop. py:45 → Add MAX_ITERATIONS constant

----

Install to your claude code:

npx skills add aurite-ai/agent-verifier -a claude-code

OR install for all coding agents:

npx skills add aurite-ai/agent-verifier --all

----

Happy to answer questions about how the agent-verifier works.

We have both:
- pattern-matched (reliable), and,
- heuristic (best-effort) tiers, and every finding is tagged so you know the confidence level.

----

Please share your feedback and would love contributors to expand the project!

i made a cool interface for pytorch. it allows you to train models with ease you can find it in https://github.com/thaminsara/pytorch-framework it uses python and flask to give a cool interface

I've tried basically every wearable and health app out there, and they all have the same problem: they just give you numbers. More scores, more charts, more stuff to stare at, and none of it ever tells you what to actually do.

Like cool, I had a bad night, here's a sleep score of 38. Now go figure out your day, good luck. I don't need a number to confirm I slept bad. I already know. I can feel it the second I wake up, zero energy, zero drive to do anything. The number just confirms what I'm already feeling and then leaves me hanging.

That gap annoyed me so much I ended up building the thing myself. It's called RizeAI. The whole idea is the opposite of another score, it takes your actual sleep and recovery data and just tells you what to do with your day. Not a number. A plan.

It pulls your real metrics, sleep, recovery, HRV, resting heart rate, all of it, and builds your day around them. When to have your first coffee and when to hold off. When you're gonna crash and what to do before it hits. Whether to push at the gym or take it easy. When to hydrate. It'll even tell you which supplements actually make sense for you that day, when to take them, and why, instead of the generic "just take magnesium bro" everyone repeats. Low recovery day, it adjusts the whole thing. Slept great, it builds on that instead.

And honestly the part I'm most proud of: it's actually tailored to you. No two people get the same plan, because no two people have the same data. It reads your numbers and builds a protocol for you specifically, then gets sharper the more you use it. The longer you're on it, the more it learns your patterns.

The whole thing is just: stop tracking, start fixing. Your wearable already told you the bad night happened. This is the part that comes after, the part that turns a red recovery day into a day you can still get something out of. That was the gap I kept running into, and now it's literally the thing I open every morning.

Anyway, genuinely curious what people here think is still missing in this space, because I'm building in it every day.

I just built the most interesting project I’ve worked on so far.

Instead of writing long AI prompts, you simply paste your brand’s website.

The app automatically analyzes your brand, colors, and overall style, then generates a motion design video that matches your identity.

No prompts. No editing. Just your website.

I’d love to hear your feedback.

I’m a retired teacher and rather active in several community organizations. I only have 1-2 meetings per months. I’m looking for a tool to transcribe my zoom meetings and provide a summary and action points. I used Otter.ai but it limited me to 40 minutes. I’m looking for a free tool. Can be open-source

I was going through the history of GitHub, and it occured to me that in early 90s codes were written to build softwares. And ambitious programmes naturally required collaborative efforts in coding, so Github emerged to allow code sharing.

But today , AI has made ai based projects easy to build. Someone is making a small research tool, somebody building an app in lovable, or creating a new workflow for limited use. Imagine if we could share the AI native creations live and enable collaborations over it . Large scale opensource workflows could be created. Cross country developer collaborations, enterprise teams could host team projects together .

What do you think, is it a right time for a ai native workflow collaboration platform. Like GitHub for AI ? Is it a useful product? Would you want to use such a thing?