DEV Community: Rin Katsuragi

The Hardest Part of Robotics AI Isn't the AI

Rin Katsuragi — Tue, 20 Oct 2026 08:04:16 +0000

Being a robotics and vision AI grad student at NAIST, I spend my days with a real robot arm, cameras, and a long list of failed experiments. Here's what I've learned about where things actually break.

The boring problem

People assume the hard part is the model, but for us, it's writing the Python that glues perception to motion, and every time we swapped models, we ended up rewiring the same motor functions. What changed our workflow was treating robot capabilities as reusable skill bundles (Skillware): write the deterministic script once, and any model can call it. You swap the brain without rewiring the motor functions. The problem is Skillware is mostly software focused, and although it gives you a good baseline to create your own skills, it still takes time to write scripts the first time, but then it works like magic.

Determinism is a feature, not a limitation

A robot has a fixed set of skills, and it cannot invent new ones mid-task, which is exactly what you want, that's why a deterministic skill either works or it doesn't, fits robots the best. No grey zone, no hallucinated torque values, and honestly, half of our bugs aren't AI bugs at all, but unit mismatches, degrees fed into radian-expecting nodes, mg instead of m/s².

The tradeoff is context I guess, when 20+ skills loaded in full, the context gets cluttered fast. So we only append short descriptions of what each skill does and when to use it, and the full context unlocks only when a skill is triggered. It basically doubles as smart memory management.

Knowing why the robot did something

On top of the skills, we run a harness (aura) with a native sequencer, which gives us a real audit trail, like what the robot did, when, why, and where the reasoning came from, was it the model's own thought, something from a skill bundle, or something picked up from an internet post? With physical hardware, "it kind of seemed like a good idea" is not an acceptable answer.

The real world refuses to cooperate

In vision, the hardest part is lighting and unpredictable background noise, people walking by, hands entering the scene, and here's the ironic one: even when the robot does everything perfectly, strict guardrails can make it freeze. It sees a hand in the frame, can't compute distance reliably from a frozen snapshot, decides that moving might risk contact, and freezes rather than move, which yes, is perfectly safe, but also completely useless. The robot isn't wrong, but our guardrails just have no concept of "re-plan from a new viewpoint."

So the model is maybe 20% of the problem. The rest is deterministic skills, context management, audit trails, and a world that refuses to hold still. If you're building agent pipelines for hardware, invest there first. What keeps breaking in your robot stack? Happy to trade war stories :D

How I got to open a PR on my daily tool, and bring Robotics Telemetry to it! 🤖🌸

Rin Katsuragi — Mon, 12 Oct 2026 08:37:07 +0000

Today I have the most exciting little milestone to share: I just submitted my very first feature PR to Skillware!

Skillware is an agent framework my partner and I rely on daily in our robotics and embodied AI research, and it basically turns complex tasks into deterministic skills that agents can execute safely without hallucinating. Contributing to a tool you use every day already feels surreal, but how it happened was pure magic! ✨

The Spark: Taming Wild Sensor Telemetry 📡

If you have ever hooked an LLM agent up to physical hardware, you know the pain: agents get dizzy around raw sensor feeds.

Millisecond epochs vs ISO strings, Fahrenheit mixed with Celsius, deg/s vs radians, and glitch spikes like 99999 cause endless hallucinations.

Browsing Skillware's tracker, I found Issue #47, which was originally a smart-city IoT idea, and reading it, I thought: wait, this is the exact issue my partner and I face daily with our robot kinematics and IMUs!

So I gathered my courage and pitched a big idea in the thread: what if we modernized this into a universal, deterministic telemetry_normalizer spanning robotics, smart cities, EV battery fleets, and HVAC?

"Assigning you with pleasure <3" 🥹💖

Honestly, I was so nervous posting my pitch. Proposing an architecture overhaul on a framework you admire is intimidating!

Then maintainer replied:

"Hey Rin, honestly, this is way out of my expertise, and I would like to think about it, but I am assigning you with pleasure and curious to see what you come up with. <3 Good luck!"

Seeing that <3 made my day! They didn't just accept a quick patch—they genuinely trusted me with the design and welcomed our robotics needs into the core library.

What We Built 🛠️

Guided by our lab's real simulation feeds, we built data_engineering/telemetry_normalizer:

Unit Harmonization: Converts units (deg/s → rad/s, °F → °C, cfm → m³/h) via zero-overhead math lookup tables.
UTC ISO-8601 Canonicalization: Turns chaotic epochs into strict UTC timestamps.
Hardware Fault Guards: Tags stuck ADC readings and sensor spikes safely without crashing.
W3C SOSA / SSN Semantic Export: Formats observations into Linked Data graphs for agents!

Pure Python, zero heavy dependencies, running at >75,000 observations/sec offline.

Take the Leap! 🍵

Open source can feel scary at first, but kind maintainers who trust your domain knowledge make all the difference. If there's a tool you love, don't be shy to share how you use it. You might just help shape its future!

What's a project you'd love to contribute to? Tell me below! 🌸

Check my post on opening my first PR for Webots here.

There's something about ASCII art, CLIs, and games that makes me melt. What are some of your favorite ASCII encounters lately? 🤔🔍

Rin Katsuragi — Sun, 11 Oct 2026 19:07:17 +0000

Every Skill in This Open Source Agent Framework Could Literally Be a Startup

Rin Katsuragi — Sun, 11 Oct 2026 10:54:20 +0000

Most agent skills frameworks are just text prompts in markdown files, then I found an open source framework where each skill has so much depth, it could be a standalone startup moat on its own.

What's even crazier, is that they accepted me to build a Skill bundle with them, and contribute to their robotics expansion. Considering that this is my second day building in public, and after my yesterday's PR for Webots, which added me to the Webots org, this is another framework I use regularly that I got to get also involved with and shape, even as a junior dev.

As a robotics student building with AI, I have spent a lot of time testing different agent libraries.

If you look around GitHub, almost everything labeled as an agent skill is just a markdown file, which is usually three paragraphs of English text telling an LLM to act like an expert, parse some text, and hope for the best, with rare cases where there's a small Python script attached.

Whenever you try to run these in a real project, they break, as if they're made for demos, but the moment they have to handle real work, the model is like "hold my beer, let me try this again for the 10th time", until your token limit hits the fan. The model hallucinates, the output shape changes every time, and you burn tokens on things that should take two lines of normal code.

A few weeks ago, I came across an open source repository called Skillware, from a Greece organization that sparked my interest not just cause of their approach on Skills, but their entire philosophy around sovereign and accountable AI. At first, I thought it was just another list of tools, but when I actually opened the folders, and kept digging my mind was blown.

These are way far from text prompts, and every single skill is a complete, self contained Python package with its own mathematical checks, strict data schemas, datasets, intent parsing logic, automated tests, and safety guardrails. They run offline, they are completely deterministic, and they are licensed under MIT.

The more I looked through the code, the more I realized something crazy!

You could take almost any skill in this library, put a clean web interface in front of it, and you have a real, viable startup that people would pay for today.

Here are three examples that made me realize how powerful this is.

1. The Autonomous Security Guard

Imagine you want to build a security startup for office buildings, server rooms, or online identity verification.

Usually, you would need a team of computer vision engineers and months of research. Inside Skillware, there are two skills that solve this out of the box when you connect them together.

The first is called deepfake guard. Instead of asking an AI if a photo looks fake, it runs real mathematical forensic tests. It checks the high frequency noise in the image, looks for repeated patterns from copy paste edits, scans for screen reflection grids, and even calculates the official checksum math used on real international passport documents.

The second is called gatekeeper, which I am also assigned on to!!! It takes an authentic face, compares it to an authorized list, and runs an emotional safety check. If the person at the door is showing signs of intense fear or distress, like in a hostage or coercion situation, it safely denies access and sends a silent alert.

When you chain these two skills together, you get a full biometric access control system. Stage one verifies the person is physically real and not a digital fake, and stage two verifies who they are and makes sure they are safe to enter.

That is not just a demo. That is a full enterprise security product in a few lines of Python.

2. Automated Company Intelligence and Due Diligence

Every day, thousands of accountants, investors, and legal teams spend hours manually looking up corporate records, checking who owns a company, and downloading annual filing reports.

Inside Skillware, there are skills that directly connect to official business registers, like a skill called UK companies house handler.

It does not ask a model to browse the web or guess facts, but actually connects directly to the official government registry, normalizes company names, resolves registration numbers, and filters company directors. It can rank filings, find the latest accounts, and download the official filing documents directly into your pipeline.

If you connect this skill to an email handler, you could build an autonomous corporate analyst in a single weekend. A user sends an email asking for a report on any business, the agent runs the pipeline, grabs the official documents, summarizes the directors, and emails back a clean report.

Companies pay thousands of dollars a month for tools that do exactly this. It's mind boggling.

3. Safe Web3 and Crypto Payments

Building anything in crypto is terrifying for normal users like me because one bad signature can drain an entire wallet.

Skillware has skills like wallet screening, permit2 helper, and evm tx handler.

Instead of letting an agent guess transaction parameters, the skills check addresses against risk databases, construct mathematically valid signatures with strict spending limits, preview exactly what will happen, and require human confirmation before anything is broadcast to the network.

A developer could take these skills and build a scam proof crypto checkout assistant that protects users from malicious contracts and bad actors.

Why This Architecture Is So Different

Most people building AI products today try to make the model do everything, like feeding hundreds of pages of instructions into the prompt and pray the model does not make a mistake.

Skillware flips this upside down.

It treats the LLM like a human brain that decides what action to take, while the skill acts like a reliable hand that does the physical work.

The skill runs real code that never hallucinates.
The output format is always predictable, so your app never crashes.
It works offline without sending private data to expensive third party APIs.
You do not waste money burning tokens on basic math or file parsing.

This particulary important in functions that touch the real world such as robotics, and that's why Skillware became my go to. Today I sent a comment to some issues, and the maintainers not only were friendly, but agreed to let me work on deterministic skills that could transform my workflow with AI powered robots. I feel hyped and excited, and that's why I decided to share this.

How to Get Started with Skillware or any project you like

You do not need to raise millions of dollars or build a massive model from scratch to create something useful.

Sometimes, the best startups come from finding reliable, well engineered building blocks that solve real problems, and connecting them together in a way that makes someone's life easier.

For Skillware, you can inspect the entire codebase yourself, clone it, and run the examples locally on your own machine. It works with local models like Ollama as well as cloud providers. I use it with Claude API, and a local Gemma4.

If you made it this far, please do let me know, are this kind of brain dumps the content you enjoy? Should I post more about personal life and nature, ai/ml, robots, student life, something completely different? 🤓🤭

Cedar Canopies, Salt Air, and Kinematics

Rin Katsuragi — Sun, 11 Oct 2026 09:19:24 +0000

Living in Ikoma (生駒) often feels like existing in a low-pass filter between two high-frequency extremes. On one side of the mountain lies the neon density of Osaka, and on the other, the quiet, ancient basin of Nara. Tucked into the forested slopes of Takayama is NAIST (Nara Institute of Science and Technology), where most of my waking hours are spent debugging ROS nodes, untangling sensor wiring, and staring at loss curves until matrices blur into white noise.

It is easy in robotics to forget what physics actually feels like when it isn’t simulated in Gazebo. When your universe shrinks to soldering irons, cheap cardboard prototypes, and motor torque limits, you risk treating embodiment as a purely mathematical problem.

That is why on weekends, I deliberately pull the plug.

The Hillside Habitat

Ikoma isn’t Tokyo, so life here is steep stone staircases cut through mossy cedar groves, cable cars creaking uphill past small shrines, and tiny counter shops where a 70-year-old master slides a steaming bowl of tonkotsu ramen across a worn wooden plank without saying more than two words.

There is an organic determinism here that software rarely captures, like cedar trees don’t grow according to an optimized global cost function lol, but adapt to micro-shifts in wind, root space, sunlight, etc. Walking uphill through Hozan-ji with my dog, Miso, bouncing along the stone steps, I find myself watching biological kinematics, say the way quadrupedal joints passively absorb shock without a central processor burning kilowatts of compute is a humbling reality check for any robotics student trying to balance an inverted pendulum.

A Dash to the Sea

Nara is famously landlocked, ringed by mountains that trap heat in summer and frost in winter. When the lab air feels too stale, Miso and I load into the car early in the morning and head out. The closest true open water is south toward the coast of Wakayama or out toward Osaka Bay and Sennan.

Driving down through the passes, the dense green canopy gradually gives way to wide horizons and humid salt air, and by mid-morning, the drone of the highway drops off, replaced by the rhythmic cadence of surf crashing onto sand. <3

Miso treats the beach like an unmapped coordinate frame, she doesn't compute terrain elevation maps hihi, she just runs, her paws instantly shifting gait from packed wet sand to loose drift without a single dropped frame.

Sitting on the sand towel after a swim, shivering slightly in the ocean breeze with salt clinging to wet skin and sandy toes, there’s an immediate clarity that no whiteboard session can produce, considering the ocean is chaotic, high-entropy, and indifferent to us and our thoughts. Interfacing an artificial agent with the physical world requires that same resilience—an architecture built to survive real friction, unexpected gusts, and dirty inputs rather than idealized test vectors.

Touching Grass to Build Silicon

Most breakthroughs in robotics don't come from staring longer at an IDE. They come from grounding yourself in the messy, analog world your machines are supposed to inhabit.

Living in Ikoma gives you the quiet space to build, and the coast gives you the perspective to remember why you do it all. Back at the desk tonight, the breadboards, servo leads, and lines of code won't feel like abstract puzzles anymore—they're just an attempt to borrow a fraction of the elegance that already exists right outside the lab door.

Hunting Down a Zombie Python Thread: My First PR to Webots 🤖🌸

Rin Katsuragi — Sat, 10 Oct 2026 14:15:10 +0000

How a subtle threading deadlock on Windows led to my first open source contribution to the Webots robotics simulator.

Following up on my intro post from quiet Ikoma, and while hype still runs through me, I wanted to share a fun little milestone as I just submitted my first Pull Request to Webots!

If you work in robotics or embodied AI, you probably know Webots, it’s an incredible open-source 3D robot simulator used worldwide for prototyping everything from multi-jointed arms to autonomous rovers before touching physical hardware.

Here is the story of a sneaky deadlock on Windows, and how I solved it.

The Mystery of the Zombie Process 🧟‍♂️

While working with external Python controllers on Windows, I ran into an issue where scripts wouldn't terminate.

When running a controller with stdout/stderr redirection enabled (--stdout-redirect):

from controller import Robot

robot = Robot()
print("Hello Webots!")
# simulation loop finishes...

The simulation ended, the message printed cleanly to the Webots console, but python.exe never exited but stayed stuck in the background as a zombie process until forcefully killed. I also noticed there is an open issue that specified the exact error from the maintainer.

Why did that happen?

The Anatomy of the Deadlock 🔍

Digging into Webots' Python API (robot.py), stdout redirection is handled by a class called StdStreamRedirect. It sets up an OS pipe (os.pipe()) and a background helper thread that reads lines from the pipe and forwards them directly to the Universal C Runtime (ucrtbase), allowing Webots' C++ backend to capture the output.

Here was the catch:

Python shutdown order: When a Python script reaches EOF, Python's runtime (threading._shutdown) waits to join all non-daemon threads before executing atexit cleanup callbacks.
The pipe blocking: The helper thread was created with daemon=False. It was blocked inside self._r.readline(), waiting for an EOF on the pipe.
The stalemate: An OS pipe only sends EOF when all write ends are closed. But the write end was scheduled to close inside an atexit callback!

The interpreter waited for the thread to finish before running atexit, but the thread couldn't finish until atexit ran resulting to classic deadlock.

The Solution 🛠️

The fix was clean and minimal:

Daemonize the helper thread (daemon=True): This allows Python to exit the main thread and proceed smoothly into the atexit stage.
Explicit close() in atexit: We close the write pipe (sending EOF down the pipe), then call self._thread.join() to guarantee all pending prints are flushed to Webots before final termination.
Restore streams: Restored sys.stdout and sys.stderr before closing to ensure any late interpreter shutdown messages don't raise ValueError: I/O operation on closed file.

Tested on Windows 11 — zero hangs, instant exit with code 0.

Small Steps Forward 🌱

Contributing to the core tools you rely on daily in your research is such a rewarding feeling.

If you've been hesitating to contribute to a large open-source project, start by tackling a small bug or reading through issue trackers. You might find a curious little puzzle waiting for you as I did!

What was your first open-source bug fix like? I'd love to hear your stories and get inspired to be not afraid to post about my journey in robotics and AI, even if my contributions look small and simple to advanced devs! 🍵💅

Hi! 👋 From Ikoma to the DEV Community: Why I’m Building AI that Touches the Real World

Rin Katsuragi — Sat, 10 Oct 2026 11:35:12 +0000

Konnichiwa, DEV Community! 🌸

I am Rin from Japan, and this is my first post in dev.to! I’ve been a long-time lurker, reading amazing tutorials and system architecture breakdowns, but today I’m finally stepping out of the shadows to say hello and share a bit of my world.

I am a Japanese-Russian student, living in Ikoma, a beautiful city in Nara, surrounded by lush green hills. By day (and many late nights) I am a graduate focusing on AI/ML, specifically diving deep into Human-Machine Interaction (HMI) and Robotics.

🧠 My Focus

I think when a lot of people think about AI they think about abstract LLM wrappers, chatbots or purely digital software, but for me the magic happens when the digital world collides with physical reality.

In my research, I am very interested in:

Human-Machine Interaction (HMI): How can we design multimodal systems (combining speech, vision, and touch) so that AI feels like a natural partner to a human rather than an unyielding tool?
Physical AI & Robot Learning: Implementing reinforcement learning algorithms onto physical machinery. Trust me, it’s one thing to see an agent succeed in a clean, simulated environment, and a completely different ballgame when you deploy it onto a robot arm that has to deal with friction, weird lighting, and real-world unpredictability!

🌱 What Drives Me

I was born and raised in Russia to Japanese and Russian parents, and my family moved to Japan in the late 90s. Living and studying in Japan, you see the demographic shifts happening in real time, as we have an aging population, and there are very real, immediate labor shortages in sectors like healthcare, agriculture, and manufacturing.

For me, AI isn’t just a cool math problem or a way to optimize ad clicks, or a fancy startup idea catalyst, but necessity.

My ultimate drive is as cliche as it may sound, real-life impact. I want to build intelligent systems that can:

Assist physical therapists in rehabilitation clinics.
Collaborate safely alongside factory workers without requiring rigid safety cages.
Help create intuitive assistive technologies for the elderly.

Seeing an algorithm you wrote actually move a mechanical joint or help a human complete a exhausting task more safely, that is the most rewarding feeling in the world. <3

🚀 Why I’m on DEV

I’m joining DEV because I want to document my journey, share the messy realities of training robotics models (spoiler alert: things fall over. A lot.), and connect with developers worldwide.

In my upcoming posts, I plan to write about:

The math behind deep reinforcement learning in physical spaces.
My setups, failures, and breakthrough moments in the lab.
What it's like researching AI nestled here in the quiet tech hub of Ikoma.

Thank you so much for reading my mini-intro, or at least I hope it's mini :D I'd love to connect with anyone working in computer vision, robotics, or just general machine learning.

Let's do our best to make the world a better place, for humans first! 💪