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.

https://preview.redd.it/kbwar29b6fuh1.png?width=1672&format=png&auto=webp&s=a4f92c6ef50fa8fe0d30468fcfdbabe5b5a300df

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, etc...), it does not care what sensor hardware you solder on down the line.

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.

Got a 3D printer and love chess?

We just open sourced New York Chess Set, one of our bestselling toys. Now you can print your own set at home for free.

https://preview.redd.it/0i0oqpbwu0uh1.jpg?width=1600&format=pjpg&auto=webp&s=caf5135fc0e48cb8ec8da51df6c938d67b90224a

Both armies share one shape per role. Each silhouette comes from a New York landmark or from the water tanks on the city's roofs, stylized so the chess role reads first.

• Pawn: 1.6 in tall, a short water tank under a conical roof, the fixture on a thousand New York rooftops.
• Rook: 2.0 in tall, Brooklyn Bridge tower, paired pointed portals and strong corner crenellations, after the bridge’s stone towers.
• Knight: 2.3 in tall, City horse, a horse head in side profile with a forward muzzle and blunt ears, cut in the same stepped planes as the towers.
• Bishop: 2.5 in tall, Flatiron Building, a long wedge with a narrow blunt prow, gridded facades, a projecting cornice and a shallow diagonal mitre mark.
• Queen: 3.0 in tall, Chrysler Building, four stepped tiers of semicircular crown with triangular windows on both faces and a short peak.
• King: 3.4 in tall, Empire State Building, the tallest tower: a long narrow shaft over broad setbacks, finished with a stout cross in place of the mast.

Each piece stands for a New York's famous landmark

Walking along the border, you'll find five city's symbols, each drawn from documented history in one New York community. Both players share the border; no neighborhood belongs to a side.

• Queens: Right edge with train cars above rails and a row of repeated piers, draw from Queens’ elevated transit and the 7 line linking its communities.
• Staten Island: Bottom right of the frame with a long ferry hull with stacked decks and wake strokes, draw from Staten Island’s daily harbor connection to Manhattan.
• The Bronx: Top left of the frame with a DJ deck, draw from the Bronx's hip-hop culture.
• Williamsburg: Left edge with Round-headed masonry openings next to a chimney stands for Williamsburg’s waterfront industrial history.
• Chinatown: Bottom left of the frame with Recessed gallery fronts and a sharply bent street line based on Chinatown’s adapted association buildings and the bend of Doyers Street.

We open source this design here: New York Chess Set

Click 3D at the bottom left to download the STL/STEP files or open in your slicer. Time to get your printers warm up for the upcoming holiday presents!

https://preview.redd.it/rnz9jx4ou0uh1.png?width=1891&format=png&auto=webp&s=9e78c02e699c9e8f52275885945a76939c8cb986

This is our latest build for a small, 50-seat team (including all departments), who wants to keep their data off grid.

Let’s start with the main stars here: 4x RTX 5090, 32GB VRAM each, 128GB in total. A decent number to run DeepSeek V4 flash, which is good enough for agentic tasks.

When it comes to 4x GPU setup, people usually pick either 4U rackmounts or supermicro 4U/super tower cases.

We don’t. Life is too short, so why not make it a little prettier. The cards are radially mounted around a vertical axis. This gives the rigs a cool look while leaving the cards space to breathe. Airflow is mapped with 18 fans so the whole box never overheats even at full load.

This case is CNC'd from 5mm solid aluminum plates, milled inside and out. The triangular cutout patterns does double duty: it keeps the frame stiff without the weight.

Each of the 4 GPUs reaches the board over its own PCIe 5.0 riser, custom-cut and sleeved to fit the chassis exactly.

Four cards pull close to 3,000W, so it runs two 2,000W supplies with native 12V-2x6 into one distribution board, off the rear, for headroom.

Underneath is an ASUS W790E-SAGE SE with a Xeon w5-3423.

Full BOM:

1.      Mobo: ASUS W790E-SAGE SE

2.      CPU: Intel Xeon w5-3423

3.      GPU: 4* RTX 5090

4.      Risers: 4* PCIe 5.0 x16

5.      PSU: 2x cooler master v1600 v2, 240V

6.      Cooling: 18* Thermalright TL-N12-R9

7.      Memory: 6* Samsung 32GB DDR5-4800 ECC Registered

8.      Storage: SSD Samsung 980 PRO 2TB PCIe 4.0

Full build video if anyone wants the detailed walkthrough happy to answer anything on the layout, cooling, etc...

Built by Autonomous.

I shared this build several times before (some called the pic AI gen 😂). Finally have the chance to record the full process with detail steps.

The two RTX PRO 6000 Blackwell cards are stars here. 96GB each, 192GB of GPU memory combined in a single machine, more than enough for multi users to run models like Qwen3.8-27B or larger models like DSv4 Flash at Q4 or Q5.

We benchmark this rig with DSv4 Flash and here's the numbers:

https://preview.redd.it/zg9oxcp9zuph1.png?width=1889&format=png&auto=webp&s=0125bac6b27fd8f7c2f075ee975e8afc08bd6e4f

We don't go with traditional tower cases or bent-steel boxes. This case is designed and CNC-machined from 5mm aluminum plates. This allow us to fully control of the airflow inside and the whole box acts like a large heatsink for the entire system. The triangles cutouts keep the whole structure stiff without dead weight.

Power and Thermals

Peak per-card draw of 509 W is 85% of the 600 W TDP. Temperatures top out at 76 °C, comfortably below the ~83–88 °C throttle point, and SM clocks held ~2.75 GHz throughout sustained load. No thermal or power throttling was observed in any test.

Sustained wall draw at the operating point is roughly 1.07 kW (815 W GPU plus CPU, memory and platform), implying a 1500 W PSU for a two-card build with headroom.

https://preview.redd.it/8dmhlsbbzuph1.png?width=1886&format=png&auto=webp&s=870bff33540877cc1ecf45aeeaf75a64bfa96221

Specs:

• CPU: Intel Xeon w5-3423
• Board: ASUS Pro WS W790E-SAGE SE
• Memory: Samsung 32GB DDR5-4800 ECC Registered x 4
• GPU: NVIDIA RTX PRO 6000 Blackwell 96GB x 2
• Cable: PCIe 5.0 x16 GPU Extension Cable Gen5 x 2
• Storage: SSD Samsung 980 PRO 2TB PCIe 4.0
• Cooling: Thermalright TL-B12 (fan kit + control) x6 + Heatsink 4677-2UAF8
• Power: CANNON PRO 2000W (12V-2x6)
• Chassis: Autonomous Computer-2 Design, CNC-machined

Full build video if anyone wants the detailed walkthrough happy to answer anything on the layout, cooling, or how the cards perform.

Another Thursday at Autonomous!

What do you see?

TLDR: Old Thinkpad T480, no discrete GPU. I run Omarchy and OpenCode on it, pointed at my Grid. Grid routes each request to whichever machine serves that model.

Disclosure: Autonomous Grid our open-source project, but the point of this post is less about the Grid itself and more about what you can do with an old laptop.

Heard about Omarchy over the weekend and I have a few potato laptops on the shelf (which I don't want to get rid of but couldn't find a good use for them). So I gave it a try.

So here's the setup:

• Laptop: ThinkPad T480, i5, 16 GB, basically no GPU. Runs Omarchy for the OS and OpenCode as the coding agent in the terminal. OpenCode keeps the agent session on the T480, while model inference is handled by the Grid endpoint.
• Grid: one OpenAI-compatible URL. It routes by model name, so each request goes to the node serving that model, and only that node. The same endpoint reaches nodes on my LAN and remote ones, so from home I still hit the office box
• Nodes: we built multi-GPU rigs for our clients and some for ourselves (inluding 2xGPU, 4xGPU, 8xGPU and a Mac Studio cluster). The office box is 4x RTX PRO 6000 and serves DeepSeek V4 Flash. A 2x RTX 5090 box at home serves Qwen3.8-27B, the model I code with most. A few other boxes serve Gemma 4 31B, Muse-Glimmer-30B, and a couple of Qwen variants.

When the potato ThinkPad asks for Qwen3.8-27B, the 5090 box answers. When it asks for DeepSeek V4 Flash, the office RTX PRO 6000 box answers.

I love the T480 form factor; it is one of my favorite laptops. But it is close to useless for my current work, and I do not game or stream on a laptop, so it mostly sits on a shelf. The 5090 box works fine (works great actually), but it means I am basically stuck at my desk all day.

Omarchy and Grid end that. Omarchy is what makes the old laptop enough: it runs light on the T480 while the model work leaves over the network. I put the old laptop back to work, spend nothing extra, and still use the 5090 box's compute, even the PRO 6000 box. In my testing, I can run several concurrent agent sessions on the 5090 box without noticeable queueing.

Worth it or not?

Worth it: you already own the machines; you want a low power and portable client anywhere; and have old hardware you'd rather reuse than leave it as an expensive paperweight.

Skip: your network is the limit; you only need one small model (a single card handles it); plain SSH is enough for you.

This is my 2x RTX 5090, which do the heavy work while the T480 being the terminal

We make a desk robot called the Autonomous Lamp. 5 bus servos for the neck, a camera in the head, a mic array and an LED ring, all hanging off one small single-board computer. It's always on, always listening, meant to feel like a companion sitting next to you, not a device you operate.

But there was a problem. When it's always on, every sound in the room is a possible interaction. A coworker stops by your desk to talk and it joins in. I type on my blue switches and it joins in too. So instead of a companion you get something that talks over you all day.

Here is what we tried, what went wrong, and what we learned. Hope some of it is useful

Prototype 1. It answered everything

First prototype, I walked into the office, sat down at my desk, and before I opened my laptop, it spoke first.

Then all day. I talked to myself while reading code, it answered. I picked up my keys to leave, and it called after me into an empty room. A coworker a few meters away was talking about a project on the phone, it heard that and joined in too

It wasn't broken. It did exactly what we told it to do. What we told it to do was the wrong thing.

Living with someone doesn't mean talking the whole time

Prototype 2. "Hey Lamp"

So we did what everyone does. Say the name first, then talk.

"Hey Lamp, turn it down." "Hey Lamp, what time is it." "Hey Lamp, never mind."

Worked right away. No name, nothing wakes up. You can even put the name at the end, like "come on dance a bit, Lamp", and it still understands and still does it. That really works btw, not making it up. Our Repo is public, it's in the commit history if you want to check.

We thought we were done. Then a few days of living with it and something felt off.

You don't say "Hey Mom" every time you talk to her at dinner. This lamp is 40cm from my elbow and I was saying its name 30 times a day.

Hey Siri makes sense. The phone is in your pocket, the speaker is across the room, and neither has eyes. They really have no other way to know you are talking to them.

The Lamp has a camera and sits right beside me. We were copying a limit we don't have.

It worked. But once it worked, it was back to being a thing you operate, and it stopped feeling like the companion we set out to build.

Prototype 3. Turning toward it, which is where we are now

We argued about this for a while and kept coming back to one thing.

People don't have a button on their body. So the Lamp shouldn't either, not if it's meant to be a real companion.

For months we had been asking how to make it quieter. Every answer to that question made it feel less alive. Quieter and more alive were pulling against each other, and we kept trading one for the other.

The right question turned out to be a different one. How does a person know you are talking to them?

The answer is stupidly simple tbh. You look them in the eye and speak.

So that is what we built. If you want it to feel like a companion, you turn toward it and talk. Camera and mic together, the way two people actually do it. This is the part where having a body pays off. A smart speaker cannot do this. A thing with a camera in its head and servos in its neck can.

Two things make or break this:

• People turn before they speak, never after. Checking the camera when the mic hears something is too late, the moment already passed. So the camera measures all the time into a 3 second buffer, and when you speak the system reads back through it. That buffer holds 4 numbers per sample, not video. A timestamp, the head angle, the face size, and how far off centre it was.
• Presence is not the signal. Someone sits beside this thing all day, so seeing a person tells you nothing, and a face pointed at a monitor is still a face. What we measure is which way the head is pointed.

Then we fixed it too well.

Someone sat in front of it, looked right at it, asked it something. Nothing. Asked again. Nothing. He was sitting so close the camera cut off the top of his head, so the detector guessed where his eyes were and put them above the frame. That works out to 90 degrees. The log had him in profile 4 times in a row. Not the LinkedIn kind

The rule that fixed it: a measurement that cannot be made must not vote either way. Not measurable had been quietly counting as looking away. And there was a hardware half to the fix too. The same face box now feeds a small vertical re-aim of the neck servos, so when it frames you badly it corrects its own aim instead of blaming you for sitting wrong.

Chin resting on your hand needed its own work too. If you ever sit in front of one, try it

If you're building an always-on device and found another way to tell when someone is talking to it, I'd like to hear it. Happy to answer anything about the build. And if you read this far, ty

I just finish putting up our Autonomous Lamp. A 3D-printed desk arm that moves and talks. Runs on Autonomous OS we built for robots. We open source everything and here's the short version.

Our Autonomous Lamp

The arm

5 degrees of freedom. Five STS3215 bus servos, daisy-chained on one TTL bus, into the board through a USB adapter. One cable for the whole arm. No driver board.

First job: servo IDs. New STS3215s ship as ID 1, so I gave each a unique ID one at a time, then calibrated homing. Homing lives in the servo EEPROM, so it survives a reflash. Do it with the arm open.

Power

Single 12 V / 5 A adaptor, ~42 W sustained. A buck steps to 5 V for the board and LED ring. Amp runs on 12 V directly. Board draws ~1.8 A, spikes to 2.5 A at boot. Ring gets capped near 1 A, full white 64 LEDs would pull 3.84 A and brown out the buck. All grounds star-point at the buck output on their own wires.

Sound

Moving audio off the onboard codec killed most of the noise. A USB DAC feeds the amp through a short twisted lead, run away from the 12 V harness. The onboard codec stays wired for the sensing mic only.

Two honest gotchas: the sensing mic is the MEMS mic on the OrangePi board, so it has to be desoldered and re-mounted in the base, fiddly, but skip it and you lose ambient sensing. And the buck I used still adds a faint hiss of its own, it's on the list to swap out.

Software

Cleanest part. Flash Linux, run the installer, ~15 minutes to Autonomous OS. The robot declares its hardware in the ROBOT.md in our repo and the OS mounts only that. Behaviors are markdown skills. Type what you want in the app, it writes the skill, live on the next conversation.

The 1st prototype

The final design

What's inside the Lamp

3D printed parts

We host AI models locally but never liked those cold industrial server racks. So we designed our own chassis, something we'd actually want sitting in the middle of the office.

It's CNC'd from an 5mm solid aluminum plate, milled inside and out. The triangular cutout pattern does double duty: it keeps the frame stiff without the weight, and the triangles map to the airflow path for the four GPUs, which stand vertically. 18 fans on one controller keep it cool at full load.

Each of the 4 GPUs reaches the board over its own PCIe 5.0 riser, custom-cut and sleeved to fit the chassis exactly.

Four cards pull close to 3,000W, so it runs two 2,000W supplies with native 12V-2x6 into one distribution board, off the rear, for headroom.

Underneath is an ASUS W790E-SAGE SE with a Xeon w5-3423 and 192GB of ECC. The whole thing is 15.5 inches square and about 66lb, anodized silver.

Design files are open source if anyone wants to build one, link in comments

https://preview.redd.it/6i2lsgl97bjh1.jpg?width=1672&format=pjpg&auto=webp&s=d27e07bbae1d7200d30930ee6accd5b9a2378d61

https://preview.redd.it/ju8tdrmb7bjh1.jpg?width=2560&format=pjpg&auto=webp&s=7714e7deeb3c553caec56af005cc5ed484ec12f9

https://preview.redd.it/jsye88qk8bjh1.jpg?width=1700&format=pjpg&auto=webp&s=a2623e8aa9f87bb41227a1897062b3a57c8a10f5

https://preview.redd.it/d592v87jabjh1.jpg?width=2560&format=pjpg&auto=webp&s=c95de9fce9aa6aa3a4305e5369f2e191cc18b5b5

A thank you to people who build local-AI tools in their spare time. You put in the work, we want to send something back.

Drop your local-AI / self-host / agent / GPU-tooling repo below.
My team picks one they find interesting. No star requirement, no follow, no catch.

Winner gets a Autonomous Computer 2-GPU chassis, $999 in value, shipped free globally.

What is it? The chassis is designed by us:

1. CNC in house from solid billet aluminum,
2. Cut to fit 2x RTX 4090/RTX 5090/RTX Pro 6000 Blackwell,
3. Including 2x PCIe 5.0 risers (full x16 each),
4. Six fan-slots mapped to the airflow path.

We run one in the office every day.

Honest bit: you win the chassis plus the risers (the part you can't buy standalone). You bring the mobo, PSU, cooling, GPUs, storage, RAM build-your-own, not turnkey.

Rules: drop your repo, say a line about what it does, we pick one. No catch, shipped free.

Design to be shown in the office

https://preview.redd.it/10xsoel8oxhh1.jpg?width=836&format=pjpg&auto=webp&s=258dd4ea8a4cafedea071306232e5ec4c37d4cae

https://preview.redd.it/0zhpfdl8oxhh1.jpg?width=836&format=pjpg&auto=webp&s=7535f643cb2d7e0d84732079978cceecef9872f6

https://preview.redd.it/4fqvqdl8oxhh1.jpg?width=1672&format=pjpg&auto=webp&s=bd6d42eb159fe29db243e109db85f6f582d6d758

Been building these multi-GPU rigs for a while, and this one's the config I'm happiest with, so figured I'd share the details here.

The frame is our own design, CNC'd aluminum, tower layout: motherboard vertical in the middle, both cards mounted upright on PCIe 5.0 x16 risers, PSU hanging off the back, and a fan tray up top pulling air straight through the card stack.

The whole thing closes up with a laser-cut triangle-lattice shell. Footprint ends up around 12.5" square enough to sit comfortably on a file cabinet. It's also quite heavy, will need a second pair of hands if you want to move it around.

Specs (the unit the benchmarks ran on):

• 2x RTX Pro 6000 Blackwell (96GB each, 192GB total)
• CPU: AMD EPYC 9124 (16C/32T, single NUMA)
• RAM: 377GB
• Storage: 915GB NVMe
• PCIe 5.0 x16 to each card, no switch, no NVLink
• Serving: vLLM, TP=2

The two cards talk over PCIe P2P, which the Pro line actually supports, and we run tensor parallel (TP=2) in vLLM.

What it serves: DeepSeek V4-Flash 0731, the 284B MoE, native FP4, fully in VRAM. Pulled the network cable to check, it keeps running, which never stops being satisfying.

Numbers from our benchmark sweep (vLLM, per-stream generation):

• 1 user: 209-286 tok/s depending on content type
• 4 users: 138 tok/s each
• 8 users: 111 tok/s each
• 16 users: 75 tok/s each
• 24 users: 57 tok/s each, ~1,000 tok/s aggregate, TTFT still ~0.5s

Saturation knee is around 32 concurrent. So this box comfortably covers my whole team, with everyone still getting faster-than-reading speed.

Thermals: 815W for both cards under sustained load, 76C peak, no throttling with the top fan tray doing intake-through-stack. Noise-wise it's no laptop, but it's fine to work next to.

Lives on the cabinet next to my desk, within arm's reach. If it were loud, I'd be the first to suffer.

Happy to answer anything about the riser setup, the airflow layout, or the benchmark config. And curious what everyone else is serving on dual-card boxes, feels like 192GB is a real sweet spot right now

First, thanks to everyone who joined last week's post. Lots of impressive repos, but we only had one product to give.

So, as promised, we're making this a weekly thing.

You can re-enter with the same repo as last week, because like I said, there were so many good ones that missed the prize.

The rules stay the same:

1. Drop your repo and say a bit about it.
2. My team takes a look. If we like it, the prize is yours.
3. No star requirement, no follow, no catch.
4. The product ships to the winner for free.

You do the work for the community, and we want to say thanks.

This week's prize: Autonomous Harness (it was Fleet but beta users told us the name didn't land, so we renamed it).

What is this Harness device? If you run Claude Code on a laptop, Codex on a desktop, and a few more agents on servers, some at home, some at the office. It gets hard to manage them all. Harness lets you talk to every agent across every machine, dispatch tasks by voice, and approve or reject with a knob instead of juggling ten terminal tabs. It works with Claude Code, Codex, Cursor, etc...

Last week's winner: vdo.ninja, WebRTC video feeds into OBS, used by streamers worldwide.

Drop your repo below. Thanks for what you build.

Deadline: Sunday Aug 2nd. Winner announced on the next Tuesday.

I might not be able to reply to you all but be assure that my team will check all of the repos here.

A thank you for open source builders. You put in the work, we want to send something back.

Drop your open source repo below. My team picks one they find interesting. No star requirement, no follow, no catch. Winner gets a Fleet device shipped for free.

What's Fleet? I was running Claude Code on my laptop, Codex on my desktop, more agents on servers. No way to manage them all. So I built a device that sits on your desk and connects to every agent across every machine. You talk to it, agents send you status updates, you don't need 10 terminal tabs.

Been using the prototype for a month. Cant live without it.

Drop your repo. Thanks for what you build.

Edit: I didn't think that I can gather this many great people. I might not be able to reply to you all but be assure that my team will check all of the repos here. Will try to make this a weekly event, so for this week, the deadline is Sunday. Big thanks to all of you.

I had three machines running different models and every single day I was SSH-ing between them just to figure out which port was serving what. Ollama here, vLLM there, ComfyUI on some random port I'd forget by tomorrow. It sucked

So I wrote Grid. Basically it sits on top of all those machines and gives you one URL that routes requests to whichever one has the model you asked for. You don't need to remember IPs or ports anymore. Point any OpenAI-compatible client at it and it just works

It's got a built-in llama.cpp engine too so you can skip Ollama entirely. And recently, I added the ability to join ChatGPT subscriptions as an engine in the grid. Your local Qwen and GPT-5 sharing one endpoint. Pretty wild

There's also a desktop app available if you're not into using terminals. It offers the same functionality but is more friendly for non dev users

Using it daily but this is still in early stage. All feedback and contributions are appreciated

I kept seeing hex honeycomb used for pretty much everything so I ran some test coupons in both, same wall thickness and cell size, and just poked at them by hand and put some weight on them.

The first thing I noticed was how little the triangle ones moved. I honestly didn’t expect it but it kinda makes sense once you think about it, a triangle can only be one shape if the sides are fixed, it can't fold sideways the way a square can. So bending and twisting them did almost nothing. Downside was they were heavier and took longer, more struts packed in for the same area.

The hex ones also used less plastic for similar coverage, which is one of the reasons honeycomb shows up so often. Pushing straight down on them, the walls kind of squished and sprang back instead of cracking. Though I want to caveat that, I was printing in PETG. I tried one in thin-wall PLA and it just snapped, so the springy thing is probably a material and wall thickness thing more than the pattern.

I also printed a curved part, a wrist rest with a domed top, and the triangle lattice held up well there. That tracks with how curved shells usually get stiffened, geodesic domes are all triangles, and a flat hex sheet doesn't really want to wrap a dome without distorting the cells. So on curved geometry the triangle edge carried over, it didn't just disappear once the surface wasn't flat.

Quick way I think about it: pick the pattern by what the part needs to do. Triangles when you don't want the part moving under bending or twist, hex when you want it lighter or a bit of give and some airflow through the cells. Lots of parts probably want both in different spots.

One thing that bit me early: if the pattern walls get thinner than about 2x nozzle width (~0.8mm on my 0.4) the fine cells under-extrude and the coupons come out inconsistent, so watch that if you're comparing.

Anyone tried these on curved parts? Curious if the triangle edge holds up there or if it flips.

Every day after work I just cmd+ctrl+Q to lock the screen and leave. MacBook stays plugged in, everything keeps running in the background. But the problem is when I'm home and want a file from the office machine, I'm too lazy to turn on my home laptop just to remote desktop. When I'm cooking, chilling on the couch, or out somewhere, pulling out my phone and messaging to get the file is way more convenient

Normally people think of 2 ways:

Remote Desktop, you still gotta turn on your home computer, sit down, open the app. What if you're driving? What if you're out? Don't tell me you'd pull over and grab your laptop. The question isn't "can you do it", it's "is it convenient?" Answer is no.

Cloud Storage (iCloud in my case), sync files up then download. But you have to remember to push the file up first. Half the time I forget and well, sucks to be me. Plus the free tiers give you barely any space, backing up iPhone photos/apps data sometimes doesn't even fit, let alone a whole project workspace.

And u guys IOS users know how the sync works. Besides client docs and contracts, there's personal photos and stuff too. I'm not pushing all that to someone else's cloud. Less data leaving my machine the better.

Then I found a simpler way that ties into my current setup using Grid + Hermes. Since installing it I haven't touched Ollama or vLLM apps anymore

GRID works pretty simply: it sits between your apps (Openclaw, Hermes, Cursor...) and whatever AI engines you're running (Ollama, vLLM, ComfyUI...). Instead of each engine sitting at its own IP/Port, Grid puts them all behind one endpoint on a cloud relay. Your app just points to that one link and can call any model, from anywhere. If you want it private you can set it to Private and invite people one by one. Works great for office sharing too

A few real situations I face daily:

Client says "change pricing from $500 to $450" plus some other requests. I forward the message to Hermes: "find the line with $500 and change to $450 and add the other requests to the file". Hermes edits the file directly on the MacBook disk at the office. Done. I never touch the office machine

There's this dev at my company who set up Hermes to run code with ClaudeCode. The agent pastes prompts into ClaudeCode and runs it. He said prompting through Telegram has process limits and agents don't get the full picture like you would with an IDE. Basically he recommends setting it up that way for full context + tooling. He even installed via CLI but the terminal had too many words for me

This setup is super handy if you freelance. Imagine lying in a hammock on your balcony or at a beachside cafe, client messages something urgent, pull out your phone, msg Telegram, done.

What this setup can do:
- Access files/workspace from anywhere via Telegram
- Data stays local, nothing leaks out if you run your own grid
- Hermes has persistent memory, remembers projects across sessions
- Cost basically zero
- If you don't have beefy hardware to host models, you can use models others are hosting.
- Join Grid + Lock your machine after work, your apps keep running smoothly. u can call it from home or let others call it, kinda like renting it out

Cons:
- Depends on office network, power outage or machine crash = no connection
- Speed isn't as fast as cloud APIs
- Weak office WiFi means higher latency
- MacBook uses ~RAM for the model, opening heavy apps at the same time might lag
- If your Mac is old you can only grab models to use like an API, can't host your own

Honestly the coolest part of Grid is you come home from work and instead of your laptop just sitting there waiting for tomorrow, it becomes a gateway + agent machine. Pretty convenient and fun ngl.