OpenHands

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

OpenHands AI

Gemini core part 4

https://preview.redd.it/pv22tsg2ib4h1.png?width=1918&format=png&auto=webp&s=dfeda1000090dc99c57c8150e4de46cfe2ba2e29 I just wanted him to give me a prompt, which then i can give to Nano Banana pro and generate me a completely random thumbnail, i wanted to test its capabilities, but instead of a prompt, he gave me this... 😭😭😭😭😭 submitted by /u/ObjectiveOrchid5344 [link] [comments]

Puppetmaster dramatically decreases token costs + increases context

Puppetmaster is an orchestrator + router that sits on top of the agent CLIs you already pay for (Cursor, Claude Code, Codex, OpenAI) or a plain shell when there's no harness at all. You hand it work, and it routes each task to the cheapest model that can actually do it, runs the workers as independent processes, and stores everything as durable typed state instead of one giant transcript. This is the "context-hack" Puppetmaster graphs your directories and prevents context stretching between agents. https://github.com/professorpalmer/Puppetmaster submitted by /u/ProfessorPalmer [link] [comments]

Before we spend months processing open-source robotics datasets, tell us why this is a bad idea [D]

Ps. Not pitching anything; Just trying to understand where reality differs from the narrative We're a couple of ML students, mostly worked on ML/software before, but over the last few months we've been playing with VLAs, robot datasets, and trying to understand where the field is heading. After spending a few weeks downloading robotics datasets, we were surprised by how much effort went into just getting data into a usable format. Maybe we're missing something, but it felt like every dataset had different assumptions, schemas, sensors, coordinate frames, metadata standards, and tooling. That got us wondering: How do robotics teams actually think about data sharing? Do people genuinely want access to more robot data, or is the industry moving toward "collect your own data because nobody else's transfers"? Our current (possibly very wrong) hypothesis is: The robotics ecosystem doesn't have a data scarcity problem. It has a data interoperability problem. We're considering running a pretty large experiment: Take essentially every public robot-learning dataset we can get our hands on, normalize it into a common schema, enrich it with metadata, and see how much of it is actually reusable across tasks, embodiments, and learning pipelines. Before we spend months doing that, we'd love to hear from people actually building in robotics. Where is this hypothesis wrong? Is finding data not actually a problem? Is embodiment mismatch the real blocker? Is quality the issue? Is labeling the issue? Is everyone just collecting their own data anyway? Would you ever use robot data collected by another team? If I gave you access tomorrow to every public robotics dataset through one API, what would you actually do with it? Or would you ignore it completely? ------------------------------------------------------------------------------------------------------ Edit: One clarification We're not thinking about a marketplace, proprietary format, or closed platform. The experiment we're considering is much simpler: Take as much public robotics data as possible, normalize it, enrich it with metadata/quality signals, make it searchable, and release it back to the community in an open format. Would that actually be useful to practitioners? submitted by /u/sigma_crusader [link] [comments]

[Use Case] Making GPT Image 2.0 output come to life

The new image function was great to help me get visual ideas to 3d model and design. I am about to release a paint range that is affordable to most hobbyists in Australia. A dropper bottle is a better design so I got these in bulk but didn't like the fact people would just have an unattractive bottle to hold. Most of my art related stuff is grounded in historical concepts and I've saved my business strategy and vision on gpt memories. The idea we came up with after multiple back and forth was a cathedral style tied in with Abbot Suger's history and creation of stained glass. GPT output and how I 3d modelled, printed and painted the sleeve to show the actual colour. submitted by /u/ValehartProject [link] [comments]

I Renovated My Apartment With AI. Here's What Came Out of It

Spoiler: not a single visible cable, not a single piece of furniture moved twice. When I started, I had an apartment and dimensions from the building blueprint. No designer. No clear idea where to go. But there was a desire to make something that would turn a standard apartment in a high-rise into a place of power — a place comfortable to live and work in. Instead of a designer, I took Claude. How it all began The first conversation wasn't about furniture or wallpaper. It was about direction. I didn't know what I wanted. I knew what I didn't want — kitsch, heavy classics, excessive decoration. We worked through options together. Scandinavian minimalism. Japanese wabi-sabi. Loft. Modern classic. The AI broke down each style by character, materials, color logic. Not "this would suit you," but "here's what this means, here's what this requires, here's what you'll get." In the end I arrived at Scandinavian for the bedroom. Warm, light, calm, with one deliberate accent behind the headboard. The living room–kitchen — loft with a red thread running through the whole space, because the furniture there was already concrete-grey with red niches and replacing it wasn't on the table. The hallway and corridor — neutral grey, as a transition between two characters. Three zones, three moods, one logic. The bedroom This was the most detailed conversation. A room with one window, one door, three free walls. Together we came up with: an accent wall behind the headboard with golden geometric lines, the other three walls in cream from the same collection. Tone on tone, different saturation, same texture. The seam between walls reads not as a boundary but as gradation. White matte furniture with black hardware. A wardrobe with a top cabinet almost to the ceiling. Mirrored doors reflect the accent wall — the golden lines are present even where they physically aren't. Then came the centimeters. The AI calculated. Adding up wardrobe depth, gaps, bed width, nightstands, dresser. Checking that everything fits. Whether the wardrobe door opens without hitting the nightstand. It even accounted for the arc of opening — that's a whole separate half-page story with mathematical formulas. By the end I had not "approximate distances" but specific points. Where to mount the light. Where to place the bed. Where to cut a network outlet into the baseboard. At what height to mount the TV unit so that watching half-lying down would be comfortable — that was calculated too, through mattress height plus pillows plus eye position. The living room Different approach. Here there was already furniture that wasn't being replaced: concrete-grey, red niches, black desk, grey sofa. The task — give the space one wall that would tie it all together. We decided: accent wallpaper behind the sofa, on the longest wall. Red-black-grey circles. Red from the furniture niches, black from the desk, grey from the concrete furniture — the wallpaper literally collects the room's palette into one pattern. By the way, an unexpected moment happened with this wallpaper: it turned out to have glitter, which only added character to the room — it plays so beautifully at sunset. The fridge against the same wall is white. It was bought six months ago, and buying a new one wasn't an option. The solution — a vinyl sticker. In red-black geometry. The fridge stops being a white blot and becomes part of the wall. Between the sofa and the kitchen zone — a floor lamp with shelves in a black metal frame. And on the top shelf, an object with character — a replica of an iconic artifact from a favorite horror film. Yes, the Lament Configuration from Hellraiser. A personal thing with a story. Why not? The hallway and corridor Grey wallpaper with a vertical tone-on-tone stripe along the entire perimeter. Grey — a neutral buffer between the red-black living room and the cream bedroom. The entryway unit in oak and graphite. Warm wood against cold grey gives the temperature contrast needed. The vestibule is small, the unit doesn't take up the whole wall — the remaining meter of free wall is for a shoe bench, above which there will be either a mirror or some poster. By the way, ideas for posters Claude also suggested — both within the renovation discussion and in other conversations connected to my work and hobbies. The through-line Between all three spaces there are recurring elements: Black hardware — bedroom wardrobe handles, black curtain rod, black floor lamp frame in the living room, black handles on the entryway unit. Geometry — lines on the bedroom accent wall, circles on the living room accent wall, verticals on the hallway wallpaper. Warm base — cream tones in the bedroom, warm wood in the entryway. These aren't accidental coincidences. This is the logic we built in dialogue. What the contractors got The most valuable thing about all this work — I handed the contractor not "well, roughly in the middle" but coordinates accurate to the centimeter. Where to m

I integrated a local Llama 3.2 model to act as a dynamic Dungeon Master in my indie RPG.

Hey everyone, I am not trying to sell or self promote mainly just wanted to showcase a big project I've been working on ever since I started studying data science and artificial intelligence and integrating AI into workflows and using it as an augment to create things that were previously out of reach for so many people, because if used right it can become a second brain and not a crutch. I’m the solo dev behind Void Runner, an isometric ARPG/MOBA hybrid built in Python. I recently hit a wall with traditional procedural quest generation. Hand-crafting templates gets repetitive fast, and players quickly learn the patterns to these things whether you like it or not. To solve this, I built the "Void Caller AI", a system that uses a local, quantized Llama 3.2 model to act as a dynamic Dungeon Master. Instead of just generating random flavor text, the system uses a lightweight RAG (Retrieval-Augmented Generation) pipeline. It reads live server telemetry (who died, what items were looted, which bosses were defeated recently) and weaves those actual server events into the narrative of the quests it generates. Because it runs locally via Ollama on our backend, there are no crazy cloud API costs, and latency is kept completely manageable. Here is a simplified look at how the Python backend bridges the SQLite telemetry with the Llama 3.2 prompt: import json import ollama from sqlalchemy import text from database import SessionLocal def generate_dynamic_quest(difficulty: str, target: str): db = SessionLocal() # 1. Fetch recent server telemetry for context (RAG-lite) lore_context = "" try: # Grab recent server events to weave into the narrative recent_events = db.execute(text( "SELECT username, event_type, dungeon_type FROM ai_events ORDER BY id DESC LIMIT 3" )).fetchall() if recent_events: events_str = "; ".join([f"Runner '{r[0]}' triggered a '{r[1]}' in '{r[2]}'" for r in recent_events]) lore_context = f" Incorporate this recent live server telemetry into the lore: {events_str}" except Exception as e: pass # 2. Construct the prompt with strict JSON formatting constraints prompt = f"""You are the Void Caller, a sinister AI in a dark industrial sci-fi RPG. Create a dynamic PvE extraction quest of {difficulty} difficulty. Respond ONLY in valid JSON with keys: 'title' (string), 'description' (string, menacing), 'item_name' (string), 'quantity' (integer 1-15), 'boss_name' (string, optional). {lore_context}""" # 3. Stream to local Llama 3.2 response = ollama.chat( model='llama3.2', messages=[{'role': 'user', 'content': prompt}], format='json', options={'temperature': 0.8} ) return json.loads(response['message']['content']) By forcing the format='json' parameter, Llama 3.2 reliably outputs structured data that my game engine instantly parses into a playable quest objective. If a player just died to a specific boss, the AI will literally generate a bounty quest for the rest of the server to avenge them. Would love to hear if anyone else is using local LLMs for live game state generation! You can check out the results live in our Open Beta at [void-runner.online]. submitted by /u/xSoulR34per [link] [comments]

Chat just gave me the best compliment of my life.

submitted by /u/AlabamaDemocratMark [link] [comments]

How do you keep Claude Code from forgetting your project between sessions?

I've been on Claude Code every day for about three months on the same project, and the thing that finally got to me is how it forgets everything between sessions. I tried the usual stuff. A [CLAUDE.md](http://CLAUDE.md) file, but it goes stale fast. Notes on the side, but I forget to update them. Compaction helps, though it loses the why behind decisions. So I'm curious what's actually stuck for people here. Anyone using claude-mem and genuinely trusting the auto-capture? Keeping a strict CLAUDE.md? llm-wiki to have a research wiki? Something you rolled yourself? I ended up building my own thing, mostly inside Claude Code itself. And look, I know there are already about a hundred memory and wiki tools out there, so let me give you the narrow reason this one exists. Most of them either make you upload files to build a wiki, or they just store memories and hand back raw text. Mine doesn't do either. It captures decisions and lessons in flow while I work, so I'm not uploading anything. It clusters them into wiki pages between sessions. Then it hands them back when I start the next one for retrieval or just human read it. And the whole thing lives in a real git repo, so when it remembers something wrong I can just revert it. It's free and open source, at [github.com/7xuanlu/origin](http://github.com/7xuanlu/origin) if you want to poke at it. Mostly though, I want to hear what everyone else does day to day. The re-explaining problem feels universal and I don't think anyone has really nailed it. And if you do look at mine, honestly, tell me what's wrong with it. Even if it's just "this is overkill, use X instead." I'm genuinely not sure the approach holds up yet. https://reddit.com/link/1tp9uba/video/w737l56hdp3h1/player

Claude moved back on workflows, so I've created them

I am happy to announce that I've create a library for creating a workflows using claude and claude code and CLI to for running and resuming them. You build flows from building blocks called steps. It supports parallel work, loops, Q&As and running scripts all to author powerful workflows. Best part is: steps can create hand off artifacts and prompts are handlebars templates so you can easly share context from step to step. Relay handles the orchiestration and state management. I've open sourced it as well so feel free to use it, test it, expand it. Repo: [https://github.com/GanderBite/relay](https://github.com/GanderBite/relay) Docs: [https://ganderbite.github.io/relay](https://ganderbite.github.io/relay) [flow example ](https://preview.redd.it/f5ext5b9un3h1.png?width=3680&format=png&auto=webp&s=e09ba5f35a9b38afa4b831de0365460dbbae29bf)

What AI or dev tools are people actually sleeping on right now?

Most tooling discussions I come across just end up being the same handful of products getting recommended over and over. Gets old pretty fast. More interested in the stuff flying under the radar. Repo and coding tools, self hosted setups, AI infra, terminal utilities, debugging tools, smaller projects that just do their job well. The kind of thing you only stumble on if you're deep in it. What have you actually been reaching for lately? Some stuff I’ve been checking out recently: GitAgent Open WebUI LiteLLM Continue.dev submitted by /u/Meher_Nolan [link] [comments]

I built an AI briefing tool in a few weeks. Then a second one. Then I had to build a platform.

A few weeks ago I saw a tweet that stuck with me: *"You literally have to be unemployed to keep up on AI."* That was me. I was spending 30-45 minutes every morning trying to stay current and still felt behind. So I spent a weekend building a fix. Claude searches the web for topics I care about, summarizes the signal from the noise, and drops it in my inbox before I wake up. Shared it with a few friends. They signed up. People were actually reading it. A week later I wanted the same thing for insurtech, the industry I work in. I copied the codebase, swapped the topics, and deployed a second newsletter. That's where the trouble started. Every bug fix had to be applied twice. Every design improvement. The two codebases drifted apart within days. I'd fix email deliverability on one and forget the other was still broken. Two weeks of that was enough. I needed a real platform, not two forks of the same script. **What I built** [Newsletr.ai](http://Newsletr.ai) is that platform. One codebase, one database, any number of newsletters. Each gets its own subscribers, topics, branding, and send schedule. The AI pipeline runs every morning: Claude searches each enabled topic, summarizes the top results, and sends the briefing before people wake up. I used VSCode as my IDE which was much easier to use than Claude Code CLI in Terminal. I also found it managed my tokens so much better than just using Claude Chat. **Things I learned that weren't obvious:** **Email deliverability is its own job.** My first sends landed in spam. Not bad content. I had a duplicate DMARC record in DNS from an old setup I'd forgotten about. Multiple DMARC records cause validation failure silently. Gmail also now effectively requires List-Unsubscribe headers with one-click support, or you get filtered. None of this is documented anywhere obvious. **Timezones get you in weird ways.** Cron jobs running at 4 AM UTC looked fine on paper. For newsletters in Mountain Time, those jobs were calculating "today" as yesterday, fetching stale articles for a briefing that hadn't sent yet. Subtle bug, wasted a week of sends before I caught it. **One-time access codes beat shared passwords.** I started beta access with a single password per tier stored in environment variables. Fine until I wanted to track who had what, revoke access, or hand codes to specific people. Replacing it with single-use DB tokens took about two hours and made the whole flow much cleaner. **Where it's at** Private beta, a few newsletters live, handing out access codes manually while I test it. The full subscriber lifecycle works: signup, double opt-in, preferences, unsubscribe, daily sends. If you run a niche newsletter (or want to start one) and want AI handling the daily content sourcing, I'm open to beta users. Drop a comment or DM me. Happy to answer questions about the architecture, Claude integration, VSCode, or the email pipeline.

Built an MCP server so Claude can generate music, images, and video natively. One config block.

I've been using Claude Code daily for the last few months and kept hitting the same wall: I'd ask Claude to produce a creative artifact (a song, a cover, a short video) and end up writing the API glue myself, then pasting results back into the chat. Felt backwards. So I built an MCP server around my AI generation platform. It exposes three tools to Claude: \- aw\_generate\_music (Suno, full songs with lyrics or instrumental) \- aw\_generate\_image (Z-Image Turbo, Wan 2.5 Spicy, Grok Imagine Quality, GPT-Image-2, Nano Banana 2, and others) \- aw\_generate\_video (Kling 3.0 Standard/Pro/4K T2V + I2V, Wan 2.2, Hailuo 02, Seedance, Grok video) One key. One credit pool. The agent picks the right model for the prompt. Install: npm install -g u/aetherwave-studio/mcp Claude Code config (\~/.config/claude/mcp.json or wherever yours lives): { "mcpServers": { "aetherwave": { "command": "npx", "args": \["-y", "@aetherwave-studio/mcp"\], "env": { "AW\_API\_KEY": "aw\_live\_YOUR\_KEY\_HERE" } } } } Restart Claude. Done. Prompts that work end-to-end without any additional setup: 1. "Generate a 60-second lo-fi track for a study playlist, then make me 3 album cover options in a retro Japanese print style." 2. "Take this product photo and generate a 5-second cinematic intro video for the product launch." (drop the image in chat first) 3. "Write the script for a 30-second ad about my SaaS, then generate the voiceover-friendly music bed and a matching motion-graphics opener." The agent decomposes, picks tools, runs them, hands you back the artifacts. Repo: [https://github.com/AetherWave-Studio/aetherwave-mcp](https://github.com/AetherWave-Studio/aetherwave-mcp) Dashboard + key: [https://aetherwavestudio.com/developers](https://aetherwavestudio.com/developers) Happy to answer questions about how I structured the tool schemas, what worked, what I'd do differently. v0.1.0, real users on it already, treating community feedback as the next steering signal.

AI is becoming epistemic infrastructure controlled by a handful of private individuals?

Most people treat AI as a convenient black box. Ask it something, it answers, you move on. But we’re sleepwalking into something bigger. I think Whoever controls the infrastructure of knowledge controls how people perceive reality. The Church held that position for centuries through controlling scripture. The printing press broke that monopoly by distributing interpretive power. AI is doing the opposite recentralizing it into a handful of corporations with no democratic accountability. “AI says X” is structurally identical to “studies show X” you’re invoking an authority you can’t directly access. Except with a study you can theoretically trace the source. With AI the chain is opaque by design. And it delivers wrong answers and right answers with identical confidence. There’s no texture to signal doubt. AI isn’t neutral, it’s being heavily calibrated. In the west, the models are trained to be more “ethical” maybe more liberal and always try to give you a more “balance” take on things. Chinese AI simply doesn’t allow you to access to anything that put the CCP is a bad light. The more you rely on AI in domains where you lack expertise, the less capable you become of evaluating whether to trust it. AI works best for people who already know enough to catch its errors the opposite of how most people use it. Imagine the next generation of people growing up and being shaped by these AI. I can’t help but feel nervous and scared for the future. OpenAI said 10% of our entire population has already started using chatgpt. Regardless of the accuracy of this number, I feel like we are slowly entering into a mass hallucination / blind reliance on these AI models. We’re not just offloading cognitive effort. We’re handing the dial over who shapes how billions of people understand reality to a small group of unelected, largely unregulated private individuals. submitted by /u/bubugugu [link] [comments]

Spec: Version Control for AI Agent Intent

AI agents are getting good at writing code. That is not the hard problem anymore. The hard problem is coordination. When you have multiple agents working on the same codebase, who decides what gets built? How do two agents with conflicting opinions resolve a disagreement? How does a human stay in control without reviewing every line before it gets written? Git does not solve this. Git is brilliant at tracking what changed, when, and by whom. But it operates on code that has already been written. By the time a conflict shows up in Git, two agents have already done the work, made assumptions, and written implementations that may be fundamentally incompatible — not at the line level, but at the intent level. I wanted to solve the problem one layer up. Before the code. The Core Idea Every code file in a Spec project has a paired .spec file living right next to it. app/Http/Controllers/HomeController.php app/Http/Controllers/HomeController.php.spec The .spec file is a plain Markdown description of what the code file is supposed to do. It is the source of truth for intent. Agents do not write code directly — they write proposals against the spec. The code only gets written once every agent has explicitly agreed on what it should do. The spec is never “checked out.” It has one canonical state at any moment. Agents read it, propose changes to it, and debate those proposals. When all agents agree, the session locks, the spec is updated, and only then does an implementer generate the code. Code is always the output of consensus. Never the battleground. The Flow A typical session looks like this: An agent reads the current spec and submits a proposal with reasoning attached. Not just what they want to change, but why. A second agent reads the proposal and responds — accepting it, rejecting it with specific objections, or suggesting modifications. If they get stuck, a mediator surfaces the contradiction and helps them find common ground. The mediator has no vote and no authority — it just asks better questions. When every agent has explicitly agreed on the same spec state, the session locks. An implementer reads the locked spec and writes the code. One pass. From a fully agreed specification. This means a few things that feel unusual at first: A build is never produced from a broken or partial spec. If agents cannot agree, nothing gets built. That is a feature, not a bug — better to surface the disagreement at the intent level than to discover it six files deep in an implementation. Conflicts in Spec are semantic, not syntactic. Two agents can touch completely different parts of a spec and still be contradictory. One says the controller should cache responses for 60 seconds. The other says it should always fetch fresh data. No line conflict. Completely incompatible intent. Spec is designed to catch this before a line of code is written. Every message carries reasoning. Proposals alone are not enough. The full session log — with reasoning trails — is what keeps the human comfortable staying hands-off. The Human Role The human operates at what I call a god level. You provide the original request. You can observe at any granularity — project, session, agent, or individual message. You can intervene at any point: rewrite the spec, stop a session, override an agent, shut the whole thing down. And critically, every intervention you make becomes a lesson — captured with full provenance and fed back into future sessions so the system learns from it. The goal is not to remove the human from the loop. It is to move the human up the stack. Mission commander, not task manager. You set the intent. The agents work out the details. You intervene when they get it wrong, and the system gets smarter from each intervention. The Technical Details Spec is built in Rust. Three dependencies: serde, serde_json, and tokio. LLM calls go over raw HTTP via curl — no SDKs. The provider layer is deliberately abstract. Agents, the mediator, and the implementer all talk to the same interface. Swap the provider in config and nothing else changes. Different agents can run on different models. You can run fully local with Ollama for cost control or privacy. Agent identity is explicit. You set SPEC_AGENT_ID before running commands. Without it, Spec errors with a clear message. This is intentional — the system cannot coordinate identity automatically, and a silent fallback to hostname:pid would make consensus unreachable in practice. The lesson graph lives at: ~/.spec/lessons.json It lives outside the repo entirely. Lessons accumulate across all projects and branches. Check out an old branch and you do not lose what the system has learned. Lessons are knowledge about how your agents work, not knowledge about any particular codebase. A hook system lets you plug in your own behavior at defined lifecycle points: • post-agree: fires when a session locks • post-build: fires after code is written • pre-release: fires be

Building Conifer, an open-source local inference runtime (free + open source)

Team of 5 from Princeton, and we got funding to build a local inference engine for Apple Silicon - rust, hand written kernels - and we're at the point where working with ~100 people will expose bugs/what people want tool-wise. All of this is free open source - will remain so. We're ahead of llama/mlx for small models working on similar performance for larger in the long run. Where this is going: the engine we're building supports a fully local agent that can do real work on your own files, apps, has permissions with OS kernel enforcement. Asking for any feedback and if you're really interested we're opening up a waitlist and taking 100 people into free beta and working with them 1-on-1 to writing specific tools and performance engineering on setups (sign up at https://conifer.build/feedback). Please only do this if you imagine using this and have some idea in mind, we'll release a full version later this summer but we want to build around talent. We need real usage and unrestrained feedback from ppl who run local models. site is live at conifer.build. also drop anything you want to see or ideas. conifer.build/feedback if you want to drop comment anon submitted by /u/No_Elephant_7530 [link] [comments]