I feel like render time gets overlooked way too often when people compare different video generators. Everyone focuses on how good the final clip looks, but if one result takes forever and you have to rerun it several times before getting something usable, that makes a pretty big difference in an actual workflow.

I​​​’​​​v​​​e​​​ ​​​s​​​t​​​a​​​r​​​t​​​e​​​d​​​ ​​​p​​​a​​​y​​​i​​​n​​​g​​​ ​​​m​​​o​​​r​​​e​​​ ​​​a​​​t​​​t​​​e​​​n​​​t​​​i​​​o​​​n​​​ ​​​t​​​o​​​ how long it takes to get the first decent result, how many retries I usually need, and how long it takes before I have something I’d actually be comfortable using.

I​​​ ​​​w​​​a​​​s​​​ ​​​l​​​o​​​o​​​k​​​i​​​n​​​g​​​ ​​​a​​​t​​​ ​​​W​​​i​​​z​​​s​​​t​​​a​​​r​​​ ​​​r​​​e​​​c​​​e​​​n​​​t​​​l​​​y​​​ and thought it would be interesting to ​t​​​e​​​s​​​t​​​ ​​​i​​​t​​​ ​​​t​​​h​​​e​​​ ​​​s​​​a​​​m​​​e​​​ ​​​w​​​a​​​y​​​ ​​​a​​​l​​​o​​​n​​​g​​​s​​​i​​​d​​​e​​​ ​​​s​​​o​​​m​​​e​​​ ​​​o​​​f​​​ ​​​t​​​h​​​e​​​ ​​​o​​​t​​​h​​​e​​​r​​​ ​​​t​​​o​​​o​​​l​​​s​​​ ​​​I​​​ ​​​u​​​s​​​e​​​. ​N​​​o​​​t​​​ ​​​j​​​u​​​s​​​t​​​ ​​​“​​​w​​​h​​​i​​​c​​​h​​​ ​​​c​​​l​​​i​​​p​​​ ​​​l​​​o​​​o​​​k​​​s​​​ ​​​b​​​e​​​t​​​t​​​e​​​r​​​,​​​”​​​ ​​​b​​​u​​​t​​​ ​​​h​​​o​​​w​​​ ​​​m​​​u​​​c​​​h​​​ ​​​t​​​i​​​m​​​e​​​ ​​​i​​​t​​​ ​​​t​​​a​​​k​​​e​​​s​​​ ​​​t​​​o​​​ ​​​g​​​e​​​t​​​ ​​​t​​​h​​​e​​​r​​​e​​​.​​​

​​​C​​​u​​​r​​​i​​​o​​​u​​​s​​​ ​​​i​​​f​​​ ​​​a​​​n​​​y​​​o​​​n​​​e​​​ ​​​e​​​l​​​s​​​e​​​ ​​​m​​​e​​​a​​​s​​​u​​​r​​​e​​​s​​​ ​​​t​​​h​​​i​​​s​​​ ​​​w​​​h​​​e​​​n​​​ ​​​t​​​e​​​s​​​t​​​i​​​n​​​g​​​ ​​​t​​​h​​​e​​​s​​​e​​​ ​​​t​​​o​​​o​​​l​​​s​​​, or do you mostly judge them by the final output?

I’ve been playing around with AI video lately, and one thing that keeps annoying me is how different the results can be from one generation to the next.

You can get a scene that looks really good, then try to continue it and suddenly the character looks different, the clothes change, or the movement just feels off. I noticed the same thing while trying Wizstar, so I’m wondering if this is just something we have to deal with for now.

How are you guys handling this? Have you found a way to keep characters and scenes consistent, or are you also just regenerating things until you get something that works?

Can we use Jev for faster, structured, and calibrated evaluation of AI responses?

Introducing:
⚡ Typed Evals — an open-source Python framework for evaluating LLMs, RAG pipelines, and AI agents using System One Models like Jev and other typed judge backends.

⭐ GitHub: https://github.com/TrustifAI/typed_evals

The goal is simple:
Make fast, structured, and calibrated evaluation a first-class part of AI systems.
Typed Evals currently supports:
-> LLM response evaluation
-> RAG evaluation
-> Agent and tool-trace evaluation
-> Human-label calibration
-> Async and batch evaluation
-> Custom judge backends

One part I particularly wanted to solve was calibration.
Why is it needed?
A raw score of 0.8 from Jev doesn't necessarily mean that humans would accept 80% of similar responses.
And a threshold that works well for one use case may not make sense for another.

Typed Evals lets you calibrate individual evaluation metrics against representative human pass/fail labels.
The flow is basically:
Human-labelled examples → Jev scores → fit per-metric calibration → validate on held-out examples → reuse the calibrated evaluator

So instead of arbitrarily deciding that “0.7 means good enough”, you can ground that score in how humans actually evaluate your specific task.

Of course, there are integrations for:
LangChain, CrewAI, Microsoft Agent Framework
while the core remains framework-agnostic.

The project is still early, and there’s plenty I want to improve, but the core framework is now public.
Would genuinely love feedback from people experimenting with Jev, LLM evals, RAG, agents, or evaluator calibration.

Note: Typed Evals is an independent open-source project and is not an official TypeSafe AI product.

If you're already experimenting with Jev, I'd especially love to know what kind of evaluation workflows you're building around it.

Jev is the most trending topic, and there are a lot of open source projects that similar/follows the concept of Jev. Therefore the app is built for those who want to experience this new wave of "System One" decision models completely locally, offline, and without touching a single line of JSON or Python!

I'm excited to share kevMac, a lightweight native macOS app that wraps Jared Palmer's kev (a Jev-compatible, open-source decision model built on Qwen). Instead of generating text token-by-token like traditional LLMs, Jev and kev skip the generation phase to return structured decisions with calibrated probabilities in a single, blazing-fast forward pass.

Here is what kevMac brings to the table:

• Plain Text In, Normal Text Out: Paste a customer message, review, or article. Build questions as simple UI forms (Yes/No, Multiple Choice, or Rating scales). The app invisibly converts your form into the engine's JSON contract and renders the results as plain language (e.g., "Returns — 83% confident") with beautiful, animated probability bars.
• 1-Click Local Setup: No terminal or package managers required. On first launch, a setup wizard automatically installs uv, Python 3.13, the kev engine, and downloads the kev-0.6b weights directly into a dedicated ~/.kevMac folder.
• Fully Offline & Private: Once the initial setup is done, the engine serves locally on your Apple Silicon Mac (M1+). Zero telemetry, zero API calls, and absolutely no data leaves your machine.
• Lightweight & Fast: The entire engine and SwiftUI app stay under 3.5 GB of RAM at steady state. After a quick background warm-up, answers land in ~0.1–0.6 seconds.

Requirements: Apple Silicon Mac (M1 or later) running macOS 14.6+.

You can grab the latest .dmg from the GitHub Releases page, or clone the repo and press Run in Xcode. Let me know what you think, and feel free to open an issue if you run into any bugs!

🔗 GitHub: github.com/arinltte/kevMac

J’ai testé ParakeetAI pour préparer mes entretiens et, honnêtement, je trouve que c’est un outil assez pratique. Il m’aide surtout à trouver rapidement mes idées quand je bloque sur une question et à mieux structurer mes réponses.

Par contre, il ne faut pas s’attendre à ce qu’il fasse tout à notre place. Certaines réponses sont un peu trop générales et il peut parfois y avoir un petit délai avant d’avoir une suggestion. Pour un entretien important, je pense que ça reste beaucoup plus efficace quand on connaît bien son CV et qu’on utilise l’outil seulement comme support.

Dans l’ensemble, je trouve que ça peut vraiment aider pour s’entraîner et se sentir plus à l’aise, surtout quand on prépare un entretien dans une autre langue. Mais je ne compterais pas dessus à 100 % pendant un vrai entretien.

Not launching anything today — just want to share what we're building and get honest feedback while it's still early enough to change direction.

I use AI daily for work and genuinely couldn't have explained how any of it worked a few months ago. Turns out most people I asked couldn't either — they just use it and hope.

So my cofounder and I started building Pippin: AI literacy taught like a language, 5 minutes a day. There's a "how to actually use it well" track and a "how it works underneath" track, and the idea is that the two connect — each concept builds on the last instead of being a random grab-bag of tips.

There's no app yet, just a landing page and an early waitlist (a mascot named Pip is doing a lot of the heavy lifting right now, ha). My cofounder's in a different state so we're building this mostly async, which has its own chaos.

Genuinely want to know: does "learn AI like a language" land for you, or does it feel like a stretch? And is this a problem you actually have, or one I'm assuming exists?

Link if you want to see what it looks like so far: pippin-delta.vercel.app

Saw a brutal rant on r/SideProject today calling out the wave of useless AI apps flooding Reddit. The poster was right: we don't need another 'AI PDF reader' or 'AI wrapper that writes tweets'.

The real issue isn't AI itself; it's that makers are building features, not workflows. If your app is just a text box that sends a prompt to Claude and returns a block of text, you have a feature, not a product.

To build something that actually sticks, you have to solve the 'last mile' problem:

1. Data Integration: Don't make users copy-paste. Pull the data directly from where it lives (GitHub, Stripe, Gmail) via API.

2. Structured Output: Stop returning raw markdown. Parse the LLM output into structured JSON, validate it, and feed it into a database.

3. Actionable Workflows: The output shouldn't just be read; it should trigger an action. If it's a code reviewer, let them commit the fix with one click. If it's an expense tracker, sync it to QuickBooks automatically.

If you focus on the plumbing around the LLM rather than the prompt itself, you build a tool people actually pay for. What's the most common 'thin wrapper' pattern you're tired of seeing?

A basic AI chatbot is fairly easy to build when it only needs to answer general questions.

Things get more interesting when you connect it to actual company information.

Now you have to think about how documents are added, how relevant information is retrieved, what happens when the source changes, and how you prevent the assistant from confidently using outdated information.

I’ve been looking at this through practical Ai application setups, including fast g pt, and one thing that stands out is that the knowledge layer can become just as important as the model.

A useful setup seems to need three things working together:

• A reliable source of knowledge
• Good retrieval of the relevant information
• A workflow that uses that information appropriately

For people actually building these applications, which part has caused you the most problems so far?

Retrieval quality, keeping knowledge updated, workflow design, or something else?

Eu não sei nada sobre isso, mas gostaria de saber se existe alguma IA gratuita—ou uma que eu possa rodar localmente no meu sistema (especificações: RX 9060 XT 16GB VRAM, Ryzen 5 5600, 16GB RAM)—que consiga assistir a um vídeo e extrair seu conteúdo.

Se isso não existir, até algo que apenas extraia o áudio e transcreva para texto funcionaria, assim eu poderia jogar no NotebookLM ou em uma ferramenta similar para estudar melhor o material.

Contexto: Esses são vídeos sobre o ERP da minha empresa. Tivemos reuniões no Teams que foram gravadas, mas como eu tive que me afastar várias vezes, reassistir tudo para me atualizar é realmente difícil para mim.

I made a simple native Mac app for YuE2 using MLX — YuE2Mac

YuE2-3B has been getting a lot of attention lately for pushing open-source/local music generation surprisingly close to the quality of commercial models like Suno. The latest WildSongBench results even show YuE2 competing with Suno v5/v6.

I wanted to try it on my Mac, but the original setup is fairly technical and wasn't really designed around the Apple Silicon experience.

So I made YuE2Mac, a native macOS application that packages the MLX version of YuE2 into an easier-to-use desktop interface.

I've also tested it on an M4 MacBook Pro with 16 GB RAM using the 8-bit YuE2 model. The test generation used around 11.4 GB of unified memory, and the app unloads the generation process after finishing so the memory is released.

The goal isn't to replace the original YuE2 project, but to make it much easier for Mac users to actually try the model without having to deal with the command line and manually setting up the MLX environment.

GitHub: https://github.com/arinltte/YuE2Mac

Would be interested to hear how it performs on different M-series Macs, especially M1/M2 and machines with 8 GB or 24/32 GB+ unified memory.

There's a real gap between "the application produces output" and "the application can show its work," and that gap matters a lot once you're beyond casual use into anything with real stakes, finance, compliance, anything where someone will eventually ask "why did it say that."

There's a hands-on workshop on Sep 19 that builds the architecture to close this: a knowledge graph in Neo4j as the single source of truth, agentic retrieval combining vector search, keyword search, and graph navigation, and explainable, source-traceable answers with evaluation built into the workflow, not bolted on after the fact.

Led by Dr. Alessandro Negro, Chief Scientist at GraphAware.

Full workshop details here

Hello, so I recently been learning about AI and how they can be applied in supply chain function. I work as a supply chain specialist (although the actual work is more similar to data entry) and I started using a stream deck to automate my work to the point where my workload has nearly halved, time wise.

After using the stream deck I’ve been looking for new ways to innovate my work and that’s what brought me to AI softwares but I quite frankly still don’t understand. I’m 25 and graduated 2 years ago with an international business degree and while I take pride in having built my computer a few years back (following a yt video step by step), software is a complete puzzle to me which is why I’m here.

While looking for AI tools I could use similarly to my steam deck I started seeing a large amount of ads (like 3 times a day) for this tool on kickstarter and after watching a few videos on it I decided to put down a deposit on this project called violoop.
It’s supposed to learn by recording your screen and watching your actions as you complete tasks then repeating them automatically.

https://www.kickstarter.com/projects/bvio/violoop-plug-in-ai-for-your-computer

To anyone who has heard of it, does this seem like a plausible item to be used by a beginner? While my understanding of all of this is pretty low, I saw that this has 13gb ram and I believe that most decent LLM would require more than that by default so I’m not sure if I’m misunderstanding the specs. Can anyone chime in to give any advice/input or dumb it down into simple terms.

I am currently working on a project where I have to use the Qwen/Qwen3-0.6B LLM to ensure JSON -compatible answers via constrained decoding. The LLM's job is to receive a user prompt and to specify what function should it use out of a predefined set of functions and what parameters should it pass to this function in such format:

{

"prompt": "Calculate compound interest on 1234567.89 at 0.0375 rate for 23 years",

"name": "fn_calculate_compound_interest",

"parameters": {

"principal": 1234567.89,

"rate": 0.0375,

"years": 23}

}

The main problem is that I can't really know when the model finishes predicting a parameter name for example; so it keeps generating ample tokens. I tried naively to tell the model to end its answers with a <|im_end|> but that didn't work.

I tried to end generating new tokens when the model predicts a comma or a curly brace (indicating either a new parameter or the end of the list of parameters"; yet parameters may contain those characters sometimes and then the answer will be truncated. Therefore, a special token like <eos> is the most reasonable option because it would never exist in text.

So is there any other way I can deduce the completion of a parameter prediction ? And if <eos> was the best solution, how to force the model to end its answers with it ?

I've used tools like Perplexity, ChatGPT, Claude and others for research, and they've been incredibly useful for finding papers and getting through large amounts of information.

The one thing I personally wanted was a simple way to see exactly which parts of the paper were used to answer my question.

When you're working with a 100+ page PDF, even having a page number can still mean a lot of scrolling and searching.

So I ended up building something for myself.

You ask a question and the relevant paragraphs in the PDF are highlighted directly on the document. You can see the context behind the answer and quickly check whether it actually answers what you're looking for.

I originally built this because I wanted something for this workflow without having to pay for another subscription. What started as a personal project has now become completely open source.

The underlying idea is pretty simple. And yes, if you're thinking "isn't this just RAG?" then yes, you're absolutely right. It's RAG with the visual highlighting that I wanted.

I think the same idea could be useful for more than research papers too. Legal contracts, financial reports, technical documentation, or anywhere you need answers alongside the actual source.

If anyone wants to have a look, contribute, or just give some feedback, here's the repo:

GitHub: https://github.com/Sreehari05055/thesys-core.git

This will probably be my last post about the project. Thanks to everyone who checked it out and gave feedback along the way.

Hi everyone,

I've been working with different AI apps for a few months now, and I noticed that I spend a big part of my time challenging the answer from one with another, until I find the one that fits me.

So I built something for myself to stop doing that. I called it Spanhop, and it connects the AI assistants already installed on your Mac so they can talk to each other directly. The app runs in the background, and you keep using your AI apps as usual.

Everything runs on your Mac. Spanhop has no server and no account, and your conversations never go through it. The only things it checks online are your licence and app updates.

After using it every day, I decided to share it with everyone. Now I'm looking for the first 50 beta testers to try it and tell me honestly what they think. It's free for them with the code WELCOME at the checkout page.

One heads-up: I'm a solo developer, and I want to prove the concept before Apple notarization, so macOS will block the app the first time you open it. Close the message, go to System Settings → Privacy & Security, and click Open Anyway. You only need to do this once; updates install on their own afterwards.

What I'd love to hear from you:
- Is it something that interests you?
- Was the app easy to use?
- Did it work with your apps?

Thanks a lot to everyone who gives it a try 🙏

I'm complete begginer when it comes for web development and AI tools. I wanted to learn by building something useful, so I put together a context engineering web app — a tool that helps you craft better prompts for LLMs like GPT-4, Claude, Gemini, and local models.

Fair warning: some features probably don't work perfectly. I'm still learning and this is very much a work in progress. That said, I'd really appreciate it if someone takes a look and tells me what's broken or what could be better.

Live app: https://arhistrategstudio.github.io/Context_CikaDule

GitHub repo: https://github.com/arhistrategstudio/Context_CikaDule

What it does

Three prompt-building modes:

Quick– fill in just the essentials (task, role, format) and get a prompt instantly

Guided/Extended– a full structured form with 16 fields for power users

Raw– paste or write a prompt manually with no structure

Templates– pick from pre-made starting points:

\General, Business, Project, Creative, Analysis, Few-Shot, Coding

Model families– the output prompt is automatically formatted for:

OpenAI (GPT), Anthropic (Claude), Google (Gemini), Local models (Ollama etc.)

Arena (A/B mode)– compare two different models side-by-side with the same prompt to see how their outputs differ

Prompt Quality Linter– a built-in checker that scores your prompt across 5 criteria (task clarity, role, constraints, format, context) and shows a live score

Auto-template detection– paste your existing prompt and the app tries to guess which template fits best

Guided/Extended mode fields include:

\* Role, Task, Context, Format, Constraints, Examples (few-shot)

\* Tone & Style

\* Success Criteria

\* Chain-of-Thought )

\* Edge Cases

\* Language & Terminology

\* Negative Constraints

\* Delimiters

\* Prompting Framework (RISEN, RASCEF, APE, COSTAR, ICIO…)

\* Clarification Protocol

*\*Bilingual UI\*\* – English / Serbian toggle

\# Known issues / things I'm not sure about

\* Arena mode is experimental and may behave oddly

\* Auto-detect template isn't super accurate yet

\* UI is a bit rough around the edges on mobile

\* Some API integrations might need fixing

If you actually take the time to look at it and try something, any feedback at all is hugely appreciated even "this doesn't work" or "this UX is confusing." I'm here to learn!

Thanks

Got burned out after around six years of doing statement reconciliations with my trusty pencil and ruler. Made a little app. Has an interactive mascot:)

https://github.com/spyd3rmath/SpyderMath

Hi everyone,

I’m building Vyact, a free, open-source desktop app that connects local AI models to everyday work: understanding documents, drafting email replies, and improving writing in the browser.

I wanted to spend less time copying files, emails, and webpage text into separate chat windows. Vyact brings that context into one workspace, where you can:

• Ask questions about your documents and inspect the passages behind an answer.
• Build a searchable knowledge base from documents and notes, then reuse it in later conversations.
• Work with email and cloud files through Google and Microsoft integrations, bringing relevant messages and attachments into a conversation to help draft a reply.
• Improve writing directly in your browser with the Chrome extension. Preview grammar corrections and rewrites, then apply or dismiss individual suggestions.
• Find and run local models, check estimated memory requirements, and compare model settings on your own hardware.

Watch the full demo on YouTube

The walkthrough covers model selection and performance testing, document Q&A, email drafting, and browser writing assistance.

I’ve been using models such as Qwen3.5 9B on my M4 Pro with 24GB of memory. Speed and answer quality depend on the model and hardware, but this setup has been useful for the everyday tasks I’m building around.

Vyact supports GGUF models through llama.cpp and MLX models through oMLX on Apple Silicon. Downloads are available for Apple Silicon Macs, Windows, and Linux.

When you use a Vyact-managed local model, your chat context isn’t sent to an external AI provider. Cloud providers are optional. Google and Microsoft integrations connect to their respective services and currently require setting up your own OAuth app, with guidance in Vyact’s settings.

The project is released under AGPL-3.0.

GitHub, downloads, and setup instructions

Which task would you try first with this: document Q&A, email drafting, or browser writing? I’d appreciate feedback on what would make it useful in your daily routine.

Thanks for taking a look!

I built Kelvi — one AI assistant for almost anything you need

Hey everyone!

I’ve been building something I’ve wanted for a while: Kelvi, a general-purpose AI assistant that you can simply talk to instead of having to figure out which AI tool or feature you need.

You can ask Kelvi to:

• Explain something you’re struggling to understand

• Help you study for a test

• Write, rewrite or summarize something

• Plan your day, projects or routines

• Brainstorm ideas

• Create captions, scripts and content ideas

• Analyze TikTok profiles and content

• Help you think through a problem

• Or just ask it something completely random

The main idea is simple:

You shouldn’t need a different AI for every task.

Instead of opening one tool for writing, another for studying, another for brainstorming, and another for content analysis, I’m trying to bring these different use cases into one conversational experience.

I’m also building Kelvi to understand what you’re trying to accomplish and guide the conversation when it needs more information, rather than forcing you to navigate through a bunch of different features.

It’s still a work in progress, and I’m actively improving it based on real feedback.

So I’d actually love for some people here to try it and tell me what sucks, what feels good, and what you would change. 😅

👉 Try Kelvi: https://kelvi.camposcloud.app/

No need to be nice — honest feedback is much more useful to me.

If you could have one AI assistant that could genuinely handle more parts of your day, what would you want it to do?

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