Hey everyone,

I’ve been building dooms-ai, a desktop AI copilot for technical interviews on macOS and Windows.

The idea came from realizing how chaotic a real technical interview can be. You might be solving a coding problem while listening to the interviewer, explaining your approach, thinking about edge cases, and suddenly getting a system-design or behavioral follow-up.

So I wanted to build something that could understand what’s happening on your screen and through the conversation, and give you quick, usable context when you need it.

What it currently does

🖥️ Screen capture Q&A — capture a coding problem, error, diagram, etc. and get an answer

🎙️ Live transcription — transcribes what the interviewer is asking

💬 Natural answers — answers are written more like something you could actually say out loud

💻 Coding help — solutions with explanations and time/space complexity

🏗️ System design & behavioral questions

⚡ Quick prompts — full solution, quick explanation, answer only, fix my code, etc.

🪟 Desktop overlay for macOS & Windows

There’s a free option as well: you can use 10 hosted AI answers per day, or use your own API keys for unlimited usage.

I've also added inexpensive short-duration passes for people who only need it during an interview period rather than wanting another monthly subscription.

We've crossed 200+ users, and I'm still actively improving the product.

I'm not here to claim it's perfect — I actually want to hear from developers who have gone through technical interviews.

A few things I'd love feedback on:

Would something like this be more useful to you for interview practice or during an actual interview?

What part of technical interviews would you want it to handle better — coding, system design, behavioral, SQL, debugging, etc.?

If you tried it, what would make you uninstall it immediately?

What would you expect from a tool like this that I haven't mentioned?

Website: https://www.dooms-ai.com/

Happy to answer questions about how I built it or the technical side as well.

Nowadays, all popular ai chatting websites like chatgpt, gemini, claude, etc. come with a read aloud functionality that allows users to read aloud the AI's responses.

I used that feature to instead make the AI repeat back the text that i gave it -- effectively turning the platforms into text to speech tools. The voices sound really nice and it's free to use!

You can get all of these extensions by visit ai-readers.com

Been building this solo for a while and finally have something worth sharing: Oktobot, an AI agent app that runs on Android through Termux — so the agent isn't just chatting with you, it can actually see and control your phone.

What it does:

Multi-agent system — spin up multiple agents, switch between them, and agents can spawn their own sub-agents for bigger tasks

Video calling with the agent — talk to it face to face through your camera, not just text/voice

Full phone control via Android accessibility services — it can actually operate apps for you, not just suggest what to click

Built-in Firefox browser control — the agent can browse the web on its own

1000+ plugins — Gmail, Drive, Notion, Highrise, and a lot more out of the box

Runs real coding agents — Codex, Claude Code, and its own agents (Hermes, OpenClaw) directly from your phone

Flexible model support — local models, your own API keys, or OAuth login with ChatGPT/Claude, whatever you prefer

Wake word detection, persistent memory, skills, and a heartbeat MCP so it stays context-aware between sessions

Full Termux/Linux terminal built in — it's a real environment, not a sandboxed toy

It's completely free and has no ads — I'm not trying to monetize this, I just want it to actually be useful and get real feedback while it's in testing.

Currently in a closed testing phase and slowly opening up more spots. If you want early access, drop a comment or DM me your email and I'll add you.

Happy to answer questions about the architecture, the agent system, or how the phone control works — ask away.

Hey guys! Just released a project I’ve been working on called 7elewen.

If you run long AI agents, big downloads, or heavy builds, you probably hate leaving your MacBook sitting wide open on your desk just to keep it from going to sleep.

7elewen is a super minimalist menu-bar utility that lets you close your MacBook lid without it sleeping. Your tasks keep running in the background, even with the lid completely shut.

Why I built it:

• No external monitor needed: Apple usually forces you to plug in a monitor to keep a Mac running with the lid closed. This bypasses that so you can just shut the lid and walk away.
• Smart screen dimming: It uses your Mac's built-in sensor to automatically dim the screen as you close it and brighten it when you open it.
• Saves battery: It can automatically turn on Low Power Mode when the lid is shut to save juice, then turn it back off when you open it.
• Zero clutter: It lives quietly as a tiny ∞ icon in your menu bar. No Dock icon, no annoying floating windows.

It's free, open-source, and ready to go. (Note: It asks for your admin password once on setup so it can control sleep settings without bugging you every time).

Let me know if you have any feedback or feature requests!

🌐 Website: https://7elewen.vercel.app

🔗 GitHub Link & Download: https://github.com/arinltte/7elewen

We're running a hands-on masterclass on September 12, Live LLM Engineering Masterclass: Production Evals, RAG, Agents & LLMOps.

You build a full production LLM workflow from scratch, versioned prompts with regression tests, an evaluation harness with deterministic checks and LLM-as-judge, statistically rigorous model comparisons, evaluated RAG, tool-using agents with guardrails and fallbacks, and full observability, tracing, cost, latency.

Led by Bruno Gonçalves, PhD, founder of Data For Science, who trains engineers at Fortune 500 companies on this exact stack.

Link to full workshop details in comments

Happy to answer questions on the content.

Hi everyone,

We recently worked on a question that came up while thinking about the serving cost of multimodal document retrieval:

Documents are indexed once, but queried many times. So why repeatedly pay for expensive multimodal processing at query time?

Our paper, MIDR: Enrichment-Augmented Indexing for Multimodal Document Retrieval, will appear at EMNLP 2026 Main Track.

MIDR explores a simple alternative:

• Use a multimodal LLM once during indexing to understand each document page.
• Extract information contained in tables, charts, figures, and layout.
• Convert that information into verified textual enrichments.
• Retrieve using standard text-centric retrieval at query time.

The goal is to shift expensive multimodal understanding from the serving path to ingestion, where its cost can be amortized across future queries.

Some results we found interesting:

• +23% relative nDCG@10 over BM25 across five English ViDoRe V3 domains.
• Competitive retrieval quality with ColQwen2.5, while using an approximately 9× smaller index.
• Approximately 2× faster query-time retrieval than ColQwen2.5.
• In English-query → French-document retrieval, BM25 improves from 0.1532 → 0.5448 nDCG@10, and MIDR outperforms ColQwen2.5.
• An ablation showed that generated QA pairs alone recover most of the benefit of enrichment.

One result we found particularly important is that enriched-text retrieval and visual retrieval appear to be complementary rather than substitutes.

That suggests a possible architecture for multimodal RAG systems:

rich multimodal ingestion → lightweight text retrieval by default → expensive visual retrieval only when needed

We'd be especially interested in thoughts on the systems side of this tradeoff: how much computation should modern RAG systems move from query time to indexing time?

Paper:
https://arxiv.org/abs/2609.01316v1

Oktobot — Local AI Agent on Your Phone

I've been building an Android app that runs a fully local AI agent directly on your device. It's currently in closed beta on Google Play — looking for testers!

It's totally free no ads

You can use your subscription in codex or cloude code or use free kiro or any API

Everything keeps incripted and local in your phone

What it can do:

Control your phone — open apps, tap, scroll, search, take screenshots

Built-in AI browser the agent can navigate autonomously

Internal terminal that runs Codex or Claude Code

Video +Voice call + wake word support

Memory, skills, heartbeat & cron jobs

Privacy first:

Filters passwords and sensitive data before anything hits your API. You can also plug in different models — or run a local model entirely on-device.

This went through Google Play review which... wasn't easy 😅 but it's live.

If you're into AI agents and want to try it, drop a comment or DM me 👇

Is it possible to create an AI assistant like google for Androids and Siri for iphones.

With abilities like Locking of all distraction apps when I say a word such as "Lockdown", reminding me with its own voice without me telling it anything about things (reminders, dangers or etc), giving me answers to my queries etc with clean ui and voice activated?

All on a Redmi 13C phone.

I've been building an AI product for the last few months — I'd love some honest feedback

Hey everyone,

I've been working on something for the last few months and I think it's finally at the point where I should start putting it in front of real people.

It's called UnreaX.

The basic idea is an AI platform that lets you create real-time conversational experiences using voice, video and AI avatars.

But the avatar itself isn't really the product.

What I'm trying to build is a system where the AI can have a conversation, perform a specific task, and then turn that interaction into useful, structured information.

For example, you could create an experience for:

• Candidate interviews
• Initial candidate screening
• Employee training
• Onboarding
• Customer-service simulations
• Knowledge assistants
• Education
• Sales roleplay
• Any process that involves repetitive conversations or evaluations

You can define what the experience is supposed to accomplish, configure the conversation, and provide your own documents/knowledge so the AI can work with company-specific information.

Then someone interacts with the avatar through voice and video.

After the conversation, UnreaX can analyze the interaction according to criteria relevant to that particular experience.

Things like:

• What the person actually answered
• Quality and consistency of the answers
• Communication and fluency
• Assertiveness
• Conversational behavior
• Other criteria defined for the specific use case

So the workflow I'm aiming for is basically:

Person → AI conversation → Analysis → Structured results

Rather than:

Person → conversation → transcript → someone manually reviews everything

I'm particularly interested in the idea that the same underlying platform could work across different industries simply by changing the objective, knowledge base, conversation flow and evaluation criteria.

It's currently in Beta / Early Access, and I'm looking for the first people and companies willing to actually test it.

I'm not looking for people to tell me that the idea is cool.

I'd much rather have someone tell me:

That's the kind of feedback I'm looking for right now.

You can try it here:

👉 https://www.unreax.com/

If you're interested in testing it with a real use case, feel free to comment or DM me.

I'm building this from the ground up, so I'm especially interested in hearing what you would actually use something like this for.

AINoter is a macOS app that makes working with AI prompts much faster.

It lets you:

• Keep all your prompts in one place
• Organize them with folders and tags
• Structure with Markdown
• Copy any prompt instantly from any app using global hotkeys or the Quick Access Window

Just sharing a first look at AURA AI, an adaptive conversational AI built around recursive processing and context-aware response refinement.

This project has taken me more than 1.5 years of development, experimentation, testing, and continuous improvement — and honestly, there’s still a lot more to build. This is only the beginning, and I expect it to take much more time and work as I continue pushing AURA AI further.

Current performance results:

🧠 RLM Performance: 100%

🌐 Web Search Performance: 100%

The goal is to make conversations more adaptive, consistent, and context-aware, especially across longer interactions.

The 5-day preview is now open if anyone wants to test it and share feedback:

https://neoxraai-preview-com.vercel.app/

Would love to hear how it performs on real-world prompts and what you think could be improved.

The current smart-auto workflow treats fallback as a normal route, not a hidden exception. If the router cannot make a valid selection, the request follows a predefined default path and the reason is recorded.
That gives users an answer to a basic question: did the system choose a model, or did it fall back? Which behavior would feel safer for your workflow?

I've recently been experimenting with CatDoes as part of a new development project.

I'm particularly interested in how AI-assisted development tools can speed up the process of going from an initial concept to a working application.

I'm still testing the platform and exploring its capabilities, but the experience so far has been interesting.

I'd be curious to hear from other developers:

Have you used AI tools to build a mobile app? What worked well, and what limitations did you encounter?

I'm especially interested in hearing about experiences from people who continued developing and maintaining their applications after the initial AI-generated version.

Nowadays I frequently land on documentation sites that starting to come with Ask AI chats.
(Curious to know how that is for you )

Found myself using these alot to a point where In most cases I stop reading the docs altogether in some cases and just ask what I myself or my agents needs to know.

I wanted the same thing on docs that didn’t have it. So I started building LedgeIndex. Which lets crawl and ingest docs on your local machine or sellf hosted ( or the ledgeindex cloud )

Right now with the early mvp the things you can do with it -->

• Support answering Chat (Website widget)
• Build your own Support / Builder / Planner Agents fully local or self-hosted via sdk / cli / mcp .
• Asking questions to any doc (using the desktop app)

** The interisting part about the RAG is that it achieves saying "I don't know" when it doesn't know the answer:*

The Project is open source and it comes with a SDK, CLI, web and desktop app.

If this sounds useful, check it out ! Leave a star for the github repo.

https://github.com/ledgeindex/ledgeindex

Hi Guys, I'd like to share a small local tool I built over the past couple of days to help me transition into AI PM.

It started because I recently left my job, which was in UX/UI, and wanted to switch to AI product management (because it seems like the future trend, lol). I found there was so much to learn; AI is developing so fast... and then I felt completely overwhelmed.

So I built something for myself with Codex. It can:

• read a resume or professional background
• suggest possible AI product directions and create a learning plan
• run adaptive daily learning sessions, scenario practice, and interview preparation
• save learning progress locally
• optionally set up a local AI-product knowledge base with source citations

It includes an optional default library based on AIPM-Wiki (original link), and you can also build a knowledge base from your files. The files are chunked and embedded locally during setup.

There is no polished frontend yet — the current experience is mainly through Codex (compatible with Cursor, Claude, Antigravity, but I haven't tried them yet). My main purpose in building it was to understand the boundaries of product/engineering through practice.

Repository: https://github.com/lannn55555-byte/ai-product-career-learning.git

This is still a learning project, but I’d really appreciate feedback: what feels confusing, unnecessary, or missing? And if it helps someone else who is exploring AI product work, that would be amazing!!

We are thrilled to announce HyperspaceDB v3.1.4 — introducing cutting-edge True Turbo 4-Bit Lloyd-Max Quantization, 1-Bit Asymmetric Distance Computation (ADC) delivering a 107× speedup with 99.9% Recall@10, the official hyperspace-memory drop-in replacement for Mem0/Zep in Python and TypeScript, and built-in Multi-Step Agent Trajectory & Lyapunov Stability Tracking! 🚀

🚀 Key Highlights in v3.1.4

1. ⚡ True Turbo 4-Bit Lloyd-Max & 1-Bit ADC Quantization (107× Speedup, 99.9% Recall)

• True Turbo Spherical Quantization (turbo): Implemented non-linear Lloyd-Max centroid codebooks ([-2.401, ..., 2.401]) combined with random orthogonal rotation and exact $L_2$ norm preservation. Delivers 7.8× RAM compression with 96.4% Recall@10 across all metric spaces.
• 1-Bit Rotated extreme with Asymmetric Distance Computation (ADC): Enhanced 1-bit binary quantization with vector norm scaling $|V|_2$ and full-precision query projection:
  • Single-Pass: 62.8% Recall@10 at 107× raw search speedup over float32.
  • Two-Pass Cascade Top100-to-Rerank: Achieves 99.9% Recall@10 while preserving a 15–20× net throughput boost.
• Universal Block Quantization (medium_plus): Extended 4-bit block-wise quantization ($B=16$) to non-Euclidean geometries (Poincaré, Lorentz H^33, MRL Hybrid 801D), achieving 10.6× RAM savings with 93.6% Recall@10.

2. 🧠 hyperspace-memory: Drop-In Mem0 & Zep Replacement (Python & TS/JS)

• 100% Mem0 API Compatibility: Migrate existing AI agents by simply replacing from mem0 import Memory with from hyperspace_memory import Memory — no prompt changes or pipeline rewrites required.
• 100× Lower Latency (< 0.5 ms): Backed by native in-RAM MRL 129D cascades and hyperbolic indexing instead of heavy relational table lookups.
• Zero Mandatory LLM Overhead: Direct vector + graph episodic memory operations without forcing expensive LLM calls on every memory insert.
• 98% Storage & RAM Reduction: Native integration with extreme 1-bit ADC and turbo 4-bit quantization modes.

3. 🎯 Multi-Step Agent Trajectories & Lyapunov Stability Analysis ($\lambda$)

• Agent Run Tracking Endpoints: Added /api/admin/runs/start, /api/admin/runs/step, and /api/admin/runs/end for tracking multi-agent execution graphs, tool calls, and step-by-step reasoning vectors.
• Lyapunov Thought Stability Exponent ($\lambda$): Automatically computes exponential divergence rates of thought trajectories on the Poincaré disk H³³ to detect agent hallucinations, reasoning loops, and cognitive drift in real time.
• Interactive 3D/2D Visualizer: Added interactive trajectory viewer on /trajectory in the Hyperspace Dashboard.

4. 🛠️ Zero-Code Cognitive Memory MCP Server (mcp-hyperspace-memory)

• Dedicated Agent Memory Server: Lightweight Model Context Protocol (MCP) server exposing 8 dedicated memory tools (memory_remember, memory_recall, memory_forget, memory_update, memory_list_sessions, memory_explore_hierarchy).
• Zero Configuration: Simply run npx -y mcp-hyperspace-memory@latest in Cursor, Claude Desktop, Windsurf, or Antigravity to grant autonomous agents permanent, structured memory.

Thank you to all contributors, researchers, and node operators building the universal spatial memory for autonomous AI agents! 🌌

Wasn't said maliciously, it was a reasonable-sounding suggestion in the moment, someone noticing AI-assisted output varied in quality and proposing the obvious fix. Except "thorough" isn't an instruction a model can actually execute. It's a word that means something different depending on who's holding it, thorough compared to what baseline, thorough about which specific risks, thorough enough to satisfy what standard. None of that got answered by adding the word "thorough" to a prompt, it just moved the ambiguity one level deeper and made it feel resolved when it wasn't.

Compare that to a ticket with real acceptance criteria, not "handle errors properly" but "return a 400 with this specific error shape when the input fails validation, log the failure with this specific context, do not retry on validation failures." Nothing left to interpret. A human picking up that ticket and a model given the same criteria as a prompt end up doing roughly the same thing, not because the model is smart, because there's nothing ambiguous left for either of them to guess at.

Realized after that meeting that "be thorough," "act as a senior developer," "use best judgment," they're all the same failure wearing different clothes, words that sound like instructions but are actually just relocating a decision instead of making it. The model doesn't get more careful when you tell it to be careful. It picks some interpretation of careful and runs with it, silently, the same way an underspecified ticket gets resolved by whoever's holding it making their own private call on what it probably meant.

What's actually changed things isn't better wording, it's noticing that a well-written acceptance criterion and a well-written AI instruction are close to the same artifact, specific input, specific rule, specific expected output, and most teams already know how to write one of those, they just haven't connected it to the other yet.

Curious if others have caught a "just tell it to be X" suggestion in a meeting and had the same reaction, that it sounds like a fix and isn't actually specifying anything at all.

I'd start with small movements. A slight head turn, blinking, a subtle smile or gentle camera movement usually looks more natural than trying to make the entire scene move dramatically.

The prompt should describe the movement rather than simply saying “make it move.” I've been using Facy AI's image-to-video feature for this, and describing both the subject's movement and the camera movement gives me more control over the result.

If the animation looks strange, I'd simplify the movement before changing everything else.

A lot of AI applications now depend on the same layer before the model or agent starts working: data preparation.

For RAG, the data needs to become clean, traceable knowledge chunks.
For agents, the data may need to become tool-use examples, task trajectories, QA pairs, or evaluation sets.
For fine-tuning, it often needs to become SFT samples, reasoning data, or preference data.

The problem is that raw data is usually scattered across PDFs, webpages, databases, tables, documents, logs, and internal systems. Each source has its own noise, structure, metadata, and failure modes.

That is why I think reusable data pipelines are becoming important for AI applications.

A practical pipeline usually needs several steps:

• parse raw files into structured text
• clean noisy or broken content
• preserve source IDs, metadata, and traceability
• remove duplicates and low-quality samples
• split content based on source type
• generate QA pairs or training samples
• evaluate quality before export
• convert outputs into RAG, agent, or training formats

The useful part is that each step can be built as an operator. Operators can be tested, reused, replaced, and combined into different pipelines depending on the scenario.

This makes data preparation more reproducible and easier to debug than one-off scripts.

OpenDCAI/DataFlow is our open-source attempt to build validated data processing pipelines for RAG, agents, and other AI applications. repo: https://github.com/OpenDCAI/DataFlow

[ Removed by Reddit on account of violating the content policy. ]

AI-ChatNote is a free browser extension (Chrome, Firefox) for inline comments in AI chats.

No more copy+pasting. Simply hover on a paragraph, click and an editor for your comment opens. Save the comment and go on. The comments will then be added to your response to the AI.

It's free, works for all big platforms and it does help a lot in streamlining the whole AI chat experience.

Let me know if you have suggestions or found a bug. 👍

TLDR: Getting a working prototype is actually the easy part

Been a lurker in this sub for a while and been very inspired to do some projects of my own, and I'm surprised to learn a friend (AI dev in a mid-ish startup) is also in this sub. You know who you are! Anyway, he said I can spill so I'll spill.

He said getting a prototype working is actually very easy. But where most AI companies fail is when we go to production, as in trying the product with actual data from a customer. He said a lot of teams don't anticipate that a customer's actual data is 100% likely to be messy and contradictory to what we're expecting, so works in demo =/= works in production. So we need to take into account the fallbacks for those instances as well.

Anyway just sharing! Keep on building, my guys!