Show HN for October 7, 2025

Hey, we’re Axel and Vignesh, cofounders of Innate (https://www.innate.bot/). We just launched MARS, a general-purpose robot with an open onboard agentic OS built on top of ROS2.

Overview: https://youtu.be/GEOMYDXv6pE

Control demo: https://youtu.be/_Cw5fGa8i3s

Videos of autonomous use-cases: https://docs.innate.bot/welcome/mars-example-use-cases

Quickstart: https://docs.innate.bot/welcome/mars-quick-start.

Our last thread: https://news.ycombinator.com/item?id=42451707

When we started we felt there is currently no good affordable general-purpose that anyone can build on. There’s no lack of demand: hugging face’s SO-100 and LeKiwi are pretty clear successes already; but the hardware is unreliable, the software experience is barebone and keeps changing, and you often need to buy hidden extras to make them work (starting with a computer with a good gpu). The Turtlebots were good, but are getting outdated.

The open-source hobbyist movement lacks really good platforms to build on, and we wanted something robust and accessible. MARS is our attempt at making a first intuitive AI robot for everyone.

What it is: - It comes assembled and calibrated - Has onboard compute with a jetson orin nano 8gb - a 5DoF arm with a wrist camera - Sensors: RGBD wide-angle cam, 2D LiDAR, speakers - Control via a dedicated app and a leader arm that plugs in iPhone and Android - 2 additional USB ports + GPIO pins for extra sensors or effectors. - And our novel SDK called BASIC that allows to run it like an AI agent with VLAs.

It boots in a minute, can be controlled via phone, programmable in depth with a PC, and the onboard agent lets it see, talk, plan, and act in real-time.

Our SDK BASIC allows to create “behaviors” (our name for programs) ranging from a simple hello world to a very complex long-horizon task involving reasoning, planning, navigation and manipulation. You can create skills that behaviors can run autonomously by training the arm or writing code tools, like for an AI agent.

You can also call the ROS2 topics to control the robot at a low-level. And anything created on top of this SDK can be easily shared with anyone else by just sharing the files.

This is intended for hobbyist builders and education, and we would love to have your feedback!

p.s. If you want to try it, there’s a temporary code HACKERNEWS-INNATE-MARS that lowers the price to $1,799.

p.p.s The hardware and software will be open-sourced too, if some of you want to contribute or help us prepare it properly feel free to join our discord at https://discord.gg/YvqQbGKH

Hi HN

I’m excited to launch GreenOnion.ai — a platform that helps anyone create beautiful, editable design layouts instantly using AI.

A lot of “AI design” tools today generate images. GreenOnion doesn’t. You bring your own images — our AI handles the layout, composition, colors, and typography to turn them into cohesive, ready-to-use designs.

Every element is structured and editable — text, spacing, colors, hierarchy — not just pixels on a canvas. It’s real design generation, not image generation.

What it does:

Describe what you want (e.g. “modern poster for a coffee brand”)

AI builds a layout around your content and image

Edit and refine everything in the browser

Export for web, print, or campaigns

Why we built it: Design shouldn’t be locked behind complex tools or templates. If you can describe an idea, you should be able to see it take form — and still have full control to adjust it.

It’s live and working today: https://greenonion.ai

I’d love your feedback — whether it’s about the product, the concept, or where you think AI-driven design should go next.

Thanks for reading, — Yanjie Founder, GreenOnion.ai

Hi HN, I’m Ignacio, founder at Basekick Labs.

Over the past months I’ve been building Arc, a time-series data platform designed to combine very fast ingestion with strong analytical queries.

What Arc does? Ingest via a binary MessagePack API (fast path), Compatible with Line Protocol for existing tools (Like InfluxDB, I'm ex Influxer), Store data as Parquet with hourly partitions, Query via DuckDB engine using SQL

Why I built it:

Many systems force you to trade retention, throughput, or complexity. I wanted something where ingestion performance doesn’t kill your analytics.

Performance & benchmarks that I have so far.

Write throughput: ~1.88M records/sec (MessagePack, untuned) in my M3 Pro Max (14 cores, 16gb RAM) ClickBench on AWS c6a.4xlarge: 35.18 s cold, ~0.81 s hot (43/43 queries succeeded) In those runs, caching was disabled to match benchmark rules; enabling cache in production gives ~20% faster repeated queries

I’ve open-sourced the Arc repo so you can dive into implementation, benchmarks, and code. Would love your thoughts, critiques, and use-case ideas.

Thanks!

GitHub: https://github.com/fizzbee-io/fizzbee-mbt-examples Quick Start: https://fizzbee.io/testing/tutorials/quick-start/

Most developers agree testing is important. At the same time, most developers don’t enjoy writing tests. With AI generating code faster than ever, testing is becoming even more crucial. But even AI-generated tests need review and maintenance, which makes them another burden.

I'm introducing another form of autonomous testing - "model-based testing". Instead of writing test cases, you describe expected behavior in a Python-like specification language.

The FizzBee model can be: - Verified exhaustively for design bugs (like formal methods). - Mapped to your actual system, automatically generating the tests.

This gives you:

- No hand-crafted test cases - Automatic testing of concurrent as well as sequential behavior - No cascading test rewrites when behavior changes - No cluttering the SUT with tracing code

With FizzBee, you get both design validation (like in formal methods) and automatic test generation, saving time and effort.

Currently, only Go is supported. Java and Rust are next and would love to hear which language you’d want supported next.

I’d love your feedback!

I like making small fonts for Arduino and ESP32 projects with those little SSD1306 OLED screens. So I made this browser-based tool to help design pixel art fonts for use in those embedded projects.

It has a preview area that updates when you save your character. It can support fixed-width and variable-width fonts. And when you're done you can export the font in a few different formats.

It comes with a bunch of example fonts built-in. Also it's fully client-side code so you can save the webpage to use it offline.

If you want some inspiration for fonts, I made a bunch of really small fonts a few years ago: https://www.moonbench.xyz/projects/tiny-pixel-art-fonts/

We were using django-easy-audit to track CRUD and API events in Django. The problem: every action meant an extra database write, which slowed transactions, increased infra costs, and left us with audit tables that weren’t great for analytics.

I built django-activity-audit (PyPI) to fix this: - Extends Django’s logging system with custom AUDIT and API levels. - Captures CRUD + API request/response events as structured JSON logs. - Vector tails the logs and ships them into ClickHouse. - Grafana makes them queryable and visual.

This removes the extra DB writes, gives structured data ready for analysis, and keeps costs down.

Curious — how are others handling audit logging in Django (or other frameworks)? Do you log it, write it to a DB, or something else entirely?

Why we built it: • Claude Code: great for coding, but no video/audio support, localhost only • OpenAI SDK: single-model, no native multimedia tools • Both: no integrated DevTools for debugging agent reasoning

So, we built Mix as an alternative for multimodal applications. • Native video/audio/PDF analysis tools (via Gemini for vision, Claude for reasoning) • Multi-model routing instead of single-provider lock-in • One-command Supabase setup for cloud deployment (vs localhost-only) • HTTP architecture that enables visual DevTools alongside agent workflows • Go backend: 50-80% lower memory footprint than Node.js—efficient for concurrent agent sessions. Python and typescript clients are available

Example use cases in the demo video: portfolio analyzer that reads Excel and generates charts, YouTube search agent that finds and edits video clips.

GitHub: https://github.com/recreate-run/mix Demo video: https://youtu.be/IwgKt68wQSc

Would appreciate feedback, especially from folks building multimodal agents.

Hi HN - I’m a copywriter by trade who loves word games. A while back I wondered: what if you flipped the idea of Scrabble on its head? Instead of building words, start with a long one and carve away letters to find the smaller words hidden inside. I made a quick prototype, then my brother helped turn it into a real game.

Play Strikethrough: https://puzzle-brothers.boondoggle.studio/puzzles/strikethro...

How it works

- You get a seed word (e.g., LONGBOARD). - Delete letters from it to make valid words: LONG, BOARD, LORD, BARD, etc. - Find 10 words to beat the day’s puzzle, or be a completionist and find them all. - New puzzle daily. No sign-up required.

I’d love to know what you all think!

Hey HN,

I always have have found really difficult to see how to style my hair and thanks to LLM's that task is now possible.

So I built this free tool where you can upload your selfie (client side, we don't store anything) and we suggest you hairstyle that would suit you according to your face shape and features.

Hope you enjoy it! Any feedback is highly appreaciate :)

Cjam is an MP3 editing and playback tool for Windows.

The MP3 format itself has been stable for decades, but advances in CPU power and memory have shifted the relationship between files and hardware, creating room for new approaches to working with MP3s.

Cjam provides both a GUI and scripting interface that allow you to process large numbers of files at the frame level. This improves on existing tools, offering faster and more flexible editing and playback.

Kalendis is an API-first scheduling backend. You keep your UI; we handle the gnarly parts (recurrence, time zones, DST, conflict-safe bookings).

What it does:

• MCP tool: generates typed clients and API route handlers (Next.js/Express/Fastify/Nest) so you can scaffold calls straight from your IDE/agent tooling.

• Availability engine: recurring rules + one-off exceptions/blackouts, returned in a clean, queryable shape.

• Bookings: conflict-safe endpoints for creating/updating/canceling slots.

Why we built it:

We kept rebuilding the same "hard parts" of scheduling: time zones/DST edge cases, recurring availability, conflict-aware booking, etc. We wanted a boring, reliable backend so we could ship product features without adopting a hosted scheduling UI.

How it's helped:

We stopped re-implementing DST/recurrence math and shipped booking flows faster.

One small team (just 2 developers) built a robust booking platform for their business using Kalendis—they kept full control of their UX without spending lots of cycles on scheduling infrastructure.

The MCP generator cut the glue code: drop in a typed client or route, call the API, move on.

Some tech details:

• REST API with ISO-8601 timestamps and IANA time zones

• Recurring availability + one-off exceptions (designed to compose cleanly)

• Focused scope: users, availability, exceptions, bookings (not a monolithic suite)

MCP integration:

MCP server exposes tools like generate-frontend-client, generate-backend-client, generate-api-routes, and list-endpoints.

Add to your MCP settings:

{ "mcpServers": { "kalendis": { "command": "npx", "args": ["-y", "@kalendis/mcp"] } } }

How to try it:

Create a free account → get an API key. (https://kalendis.dev)

Hit an endpoint:

curl -H "x-api-key: $KALENDIS_API_KEY" \ "https://api.kalendis.dev/v1/availability/getAvailability?userId=<user-id>&start=2025-10-07T00:00:00Z&end=2025-10-14T00:00:00Z&includeExceptions=true"

What feedback would be most useful:

Gaps in the endpoint surface (what's missing for your use case?).

Features that would benefit this service integration in your app.

MCP generator output—anything you'd want it to emit differently?

Happy to answer questions and post example snippets in the thread. Thanks for taking a look!

— Dave (Kalendis)

While reading Agentic Design Patterns by Antonio Gulli, I wanted to see how these patterns look in real code. I cloned the OpenAI Codex repo (the open-source AI coding assistant that recently trended on HN) — but it was in Rust.

So, I used an Cursor to help me extract and translate 18+ agentic patterns from Codex’s codebase into Python. That small experiment turned into a full open-source guide: GitHub: Codex Agentic Patterns https://github.com/artvandelay/codex-agentic-patterns

Each pattern comes with:

A short explanation and code sample

A runnable exercise and agent snippet

A summary of how Codex used the pattern (e.g., prompt chaining, tool orchestration, reflection loops, sandbox escalation)

One full working Python agent that ties it all together

If you’ve read the agentic design patterns book or explored Codex, this is a bridge between theory and practice — focused on runnable, open examples instead of abstract diagrams.

It’s completely free and open-source. Would love feedback, ideas, or even new patterns from your own agent experiments.

Hey folks, Gotask is a simple golang CLI I made to explore some aspects of the Go programming language.

I built *ImBoard*, a board OS designed specifically for venture-backed startup boards and especially *first-time CEOs*.

*What It Does (The Core Value)*

Ship an *investor-ready, versioned board pack* with an audit trail (not just files).

*Enforce Data Integrity:* Keep KPIs consistent across the pack and dashboards. Our Reports are built on *strict schemas, which is key to generating reliable, AI-ready insights* (Cash, Pipeline, core metrics).

Run a *tight cadence*: agenda, scheduling, votes, decisions, and follow-ups.

Keep Docs as a *single source of truth*.

*Why I Built It (The Credibility)*

First-time CEOs often juggle... ImBoard aims to remove fuzziness and help you show up like a pro. As a *solo founder*, I've spent the last *20 months* building this as the system I wish I had as a *former CEO*. Now, as a *VC/investor*, I see its value from the other side of the table.

*What’s Different (The Competitive Edge)*

*Versioned packs + diffs* with an *audit trail*.

*Live dashboards* tied to a specific pack version.

*Scheduling & votes* without heavy calendar plumbing.

Production is *account-based* (no public links) to preserve auditability.

*Limitations (Required Transparency)*

- No Stripe/SSO/MFA today (planned).

- The *demo is read-only* (production requires email verification).

*Security and Stack*

See my first comment below for the *full technical appendix* (Stack, AI services, Testing) and detailed *security roadmap*.

*Feedback I’d Love*

Does the *guided, versioned pack* model click?

Are the *Cash/Pipeline/KPI* dashboards the right level for early boards?

Anything confusing in first-run or the demo tour?

What would block you from replacing a deck + email thread today?

Happy to answer here. Prefer email? *`[email protected]`*

• In the current demo, you can enter specifications, goals, missions, parts, and other constraints, and it will generate a full design—from system to subsystems and components—drawing on data sheets. When a user submits a request, it weighs physical constraints and part availability together to suggest the most suitable design solutions.

• I built this tool to lighten the load of poring over countless component data sheets at project kickoff and to make blueprint iteration smoother. I’m aiming beyond “hardware” to the wider class of machines without operating systems, structured hierarchically as system–subsystem–component, so we can reason clearly at each level and lower conceptual entropy throughout the design process.

• Right now, the tool excels at precise spec comparisons for off‑the‑shelf components, but there are still blind spots in modeling the full physical behavior of a hardware system. I’m investigating simulation to close that gap. It also doesn’t yet design PCBs or handle CAD modeling directly.

• I’m currently building a node‑editing feature. Very soon (within 1–2 days), you’ll be able to edit detailed information for nodes at every level. Over the next month, I’m targeting a basic 3D canvas to create and configure three‑dimensional data for hardware.

As a demo, there’s plenty to improve. I want to keep learning and evolving this tool so it can meaningfully support hardware and machine design. I’d truly value your feedback!

Hey, we’re Axel and Vignesh, cofounders of Innate (https://www.innate.bot/). Last year we shared our concept of a personal general-purpose robot that anyone can program and teach at home (https://news.ycombinator.com/item?id=42451707). Recently we launched MARS, a mobile manipulator with an open onboard agentic OS built on top of ROS2.

The video shows a walkthrough, there are more at https://docs.innate.bot/welcome/mars-quick-start.

When we started we felt there is currently no good affordable general-purpose that anyone can build on. There’s no lack of demand: hugging face’s SO-100 and LeKiwi are pretty clear successes already; but the hardware is unreliable, the software experience is barebone and keeps changing, and you often need to buy hidden extras to make them work (starting with a computer with a good gpu). The Turtlebots were good, but are getting outdated.

We thought that the open-source hobbyist movement lacks really good platforms to build on, and we wanted something robust and accessible. MARS is our attempt at making a first intuitive AI robot for everyone.

What it is:

- It comes assembled and calibrated

- Has onboard compute with a jetson orin nano 8gb

- a 5DoF arm with a wrist camera

- Sensors: RGBD wide-angle cam, 2D LiDAR, speakers

- Control via a dedicated app and a leader arm that plugs in iPhone and Android

- 2 additional USB ports + GPIO pins for extra sensors or effectors.

- And our novel SDK called BASIC that allows to run it like an AI agent with VLAs.

It boots in a minute, can be controlled via phone, programmable in depth with a PC, and the onboard agent lets it see, talk, plan, and act in real-time.

Our SDK BASIC allows to create “behaviors” (our name for programs) ranging from a simple hello world to a very complex long-horizon task involving reasoning, planning, navigation and manipulation. You can create skills that behaviors can run autonomously by training the arm or writing code tools, like for an AI agent.

You can also call the ROS2 topics to control the robot at a low-level. And anything created on top of this SDK can be easily shared with anyone else by just sharing the files.

This is intended for hobbyist builders and education, and we would love to have your feedback!

p.s. If you want to try it, there’s a temporary code HACKERNEWS-INNATE-MARS that lowers the price to $1,799.

p.p.s The hardware and software will be open-sourced too, if some of you want to contribute or help us prepare it properly feel free to join our discord at https://discord.gg/YvqQbGKH

We compared the latest AI video tools that are challenging InVideo in 2025. This post breaks down how creators are switching to faster, more creative platforms and why these 4 tools stand out in real workflows.

Seriously, wtf is this thing?

https://github.com/ktynski/FractalRecursiveCoherence

I got tired of manually having to create a nice event in my calendar every week. From random text in an email to a flyer out in the wild.

So I made this and now use it weekly.

Was thinking about making a browser extension or phone app as well. Thoughts on that?

Who else lives and dies by their calendar?