Physical-AI-Operating-System

@smonster936 yes! lampOS is open source, so you can bring your own code, agent, or model. what are you thinking of building? autonomous-ai/lampOS

We gave Hermes a body, one eye, and two ears. Here’s how it works Hey all, David from Autonomous here. Hermes is great at living in a terminal or a chat app. We wanted to see what happens when it lives on a desk instead. So we put it in a physical AI assistant: one wide-angle camera, a mic array, stereo speakers, and 5 servos for the head. The wiring is the part I find most interesting, so here’s the quick go through of Lamp: - Hermes runs on the lamp: It runs as a local Hermes API server on the device, and the OS talks to it over HTTP + SSE. You can also point the lamp at a Hermes instance running elsewhere on your LAN. - The brain is swappable: Hermes sits behind one agent gateway interface, alongside Claude Code, Codex, OpenClaw, OpenCode, and PicoClaw. You can switch from the web UI, and the persona, memory, and connectors move with it. - It pays attention to the room: Every couple of seconds it checks for motion, faces, light, and sound, and lets Hermes know. So Hermes has context about what’s going on around it, not just what you type. - Skills are how Hermes learns the body: Each skill is a skill.md file. When Hermes wants the lamp to move or light up, it adds a small note to its reply, and the OS turns that into the actual movement. So Hermes never has to deal with servos directly, which keeps things a lot simpler. - There’s a small server in the middle: It passes messages between Hermes and the hardware, and handles things like switching agents and updates. Quick stuff like “turn off the lights” gets handled right there, so you’re not waiting on a full agent reply just to flip a light. The OS is open source if you want to poke at it: autonomous-ai/lampOS What’s the most unexpected thing you’ve run Hermes on so far?

An AI assistant you don’t have to open Most of the AI we use lives in a browser tab or on a phone. You open it, type, read the answer, and close it again. At Autonomous, we build Lamp, a physical AI agent that works the other way around. It sits on your desk and answers out loud, and before it replies it turns to look at you and its ring lights up. You can ask a question, hand it a task and hear the result, or have it remind you to drink water or take a break, all while you keep doing whatever you were doing: autonomous.ai Behind the scenes it splits things up. If you’re just chatting, it talks back right there. If it’s real work, like checking why a build failed, it hands the job to an agent on your computer and gives you a quick summary when it’s done. The bigger difference here is that it’s actually in the room with you. A chat window only knows what you type into it. Lamp can sense CO₂, temperature and humidity, so it can tell you when the room’s getting stuffy. By default it checks the air every 10 seconds, only speaks up when a change sticks around, and then holds off for half an hour so it doesn’t nag. With the camera and a sensing service, it can also nudge you when you’re slouching. The AI behind it is your choice. It runs with agents like Claude Code, Codex and Hermes, and you can switch between them without losing its personality or memory. The OS is open source: autonomous-ai/Physical-AI-Operating-System Would you actually want an AI assistant with a body or is a screen enough for you?

🔗 GitHub: autonomous-ai/lampOS --- ✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

We built a small box that runs your AI agent all day. Here are the 3 decisions that shaped it I work at Autonomous. Here we’ve been building Intern, a small desk device that runs an AI agent for you around the clock. A few people asked why it’s a box and not just an app, so here are the three decisions that shaped it, plus what we gave up for them: autonomous.ai 1. The agent gets its own place to run Most agent setups live on a laptop, which means they stop the moment the lid closes. We wanted the agent somewhere that stays on, separate from the computer you actually work on.  Intern is a 4.7 inch cube built on an Orange Pi 4 Pro (8-core ARM, 6GB LPDDR5, 64GB storage expandable to 256GB), powered over USB-C and connected over Wi-Fi 6. So it sits on your desk and runs all day.  Say you set up a morning summary or ask it to watch a GitHub repo. That keeps going overnight, and the result is waiting in your chat when you wake up, whether your laptop was on or not. 2. It comes with an agent, but you’re not locked in Setting up an agent from a repo can take a whole weekend of keys, errors, and trial and error. So Intern ships with OpenClaw or Hermes already installed. Under the hood, the OS treats the agent as a swappable piece: Hermes, OpenClaw, PicoClaw, Codex, Claude Code, and OpenCode all sit behind the same gateway, and the agent’s personality lives in a plain markdown file called soul.md rather than in code.  If you already have your own setup, the developer edition gives you an open shell to install the agent you use. 3. You talk to it where you already are We didn’t want another app you have to remember to open. Setup happens once in the app: add Intern, pick your Wi-Fi, and it handles the pairing. After that you just message it through Telegram, Slack, Discord, iMessage, or voice.  To teach it something new, you can grab a skill from the Skill Store, or type what you want in the app and it’s ready the next time you talk to it. The OS is open source if you want to poke around: autonomous-ai/Physical-AI-Operating-System If you’ve built something that needs to run all the time, did you go with dedicated hardware or a server? Would you make the same call again?

Your AI agent can reason. This repo gives it a body. Physical AI Operating System is an open-source software stack for connecting AI agents to robot hardware such as cameras, microphones, speakers, motors, lights, and sensors. It helps you build agent-driven physical interfaces by separating the robot body, skills, runtime, hardware drivers, and safety bounds into documented layers. Key features: • Multiple agent runtimes – supports Hermes, Claude Code, Codex, OpenClaw, OpenCode, and PicoClaw • Robot starting points – includes paths for Autonomous Lamp, Autonomous Intern, and Reachy Mini • Bring-your-own-robot guide – define a body with `ROBOT.md`, `SOUL.md`, `SAFETY.md`, and `SKILL.md` • Physical skills – add behaviors for sensing and interaction, then adapt or create skills in the repo • Capability and safety layers – robots declare supported capabilities while a safety gate applies configured bounds It’s open-source: Apache-2.0 outside `hal/`; `hal/` is GPL-3.0. 🔗 GitHub: autonomous-ai/Physical-AI-Operating-System ⸻ ♻️ Share this with your network if you found it useful or insightful. ✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

🔗 GitHub: autonomous-ai/Physical-AI-Operating-System --- ✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

@Captain75733660 make sure to run this OS! autonomous-ai/Physical-AI-Operating-System

3D Printed Talking Lamp: 2 months update Two months ago, I shared the initial Lamp build here: the 5-DOF arm running on STS3215 bus servos, a single 12V cable, the USB DAC to kill ground noise, and an early pass at Autonomous OS. After 2 months, lots of updates have been made. And Lamp is more than just a fun desk decoration now 1. It actually sounds like it has a mood Lamp used to run on that familiar, flat-line TTS. Recently, we switched to ElevenLabs v4 Turbo, and it changed the whole vibe. Pitch and cadence shift naturally, pauses land where they should, and a joke lands like a joke instead of a status report. We also added an on-device emotion model (emotion2vec) listening to user speech, with the head's ring light subtly reflecting how Lamp is feeling. The fun part: the personality is just a simple markdown file the agent parses on every turn. Out of the box, it behaves like a warm, curious desk companion that never breaks character with tech jargon like "servos" or "API calls." Tweak a few bullet points in that file, and you get an entirely different roommate. You edit the soul, not the code. preview.redd.it 2. It can read the room (literally) In the first build, the only inputs were the camera and the mic. I have since wired up a Sensirion SEN63C over the I2C bus, which is a single compact module reporting particulate matter (PM1, PM2.5, PM4, PM10), temperature, humidity, and true CO2. The HAL caches the latest snapshot in RAM while an OS worker polls it in the background. Lamp only fires an event when environmental metrics drift over time, rather than spamming context on every raw sample (available read-only via Web and MQTT). The practical payoff: I closed my window while someone was cooking downstairs, and Lamp chimed in that the room was getting stuffy before I even noticed. Because the agent layer only queries abstract keys (pm, co2, temperature, voc), it does not care what sensor hardware you solder on down the line. preview.redd.it 3. The brain is a hot-swappable slot Early on, Lamp was locked into a single agent runtime. Autonomous OS now treats the agent as a modular backend you define in config, completely decoupled from personality and long-term memory. I recently migrated Lamp from Hermes to OpenClaw with a single setting change. It kept the exact same voice, the same quirks, and everything it had already learned about me. The agent handles the reasoning; the soul and the memory survive the brain transplant. The entire stack is open source if you want to dig into the HAL, tweak the configs, or build your own: The OS: autonomous-ai/Physical-AI-Operating-System The hardware, with all the printable files included: github.com/autonomous-ai/Physical-AI-Operating-Sy…

@cwkdotone she's open, so you can definitely wire her into your stack autonomous-ai/Physical-AI-Operating-System