DEV Community: RYO ITABASHI

I Still Can't Write Code. But My Phone Now Wakes Itself Up at 8am to Run an Agent I Registered From a Home Screen Widget.

RYO ITABASHI — Fri, 31 Jul 2026 09:09:16 +0000

Since the last post, the agent stopped waiting for me

Last time, the AI moved into the OS: an Agent Chat pane that reads Codex events live, a Scouter widget on the home screen with quota bars and a compose box, per-category notification channels, and a Z Fold that finally survives being folded.

All of that shared one assumption I didn't notice until later. Every one of those features only did something while I was looking at the phone. The widget showed me state. The chat pane showed me state. The notification told me something had already happened. Shelly had become a very good window onto a process that still needed me to start it.

So the next question was obvious and I'd been avoiding it: what does it take for the agent to run when I'm asleep?

@agent, AlarmManager, and Doze

You write this into the Ask box, in ordinary English:

@agent every day at 8am summarize the news and notify me

What happens next is the part I care about. Shelly does not spin up a cron daemon. It does not keep a foreground service alive to poll a clock. It registers a real Android alarm through AlarmManager, using setExactAndAllowWhileIdle. AlarmManager is the OS's own scheduler — the same one your alarm clock app uses — and it fires through Doze. Screen off, app swiped away, phone face down on the nightstand. At 8am the agent wakes up, runs with your API keys and your tools, and posts the result to your notification shade.

The parser argues back. If the request is vague, it doesn't ask for a time first, which is what every scheduling UI I've ever used does. It asks what. "Summarize the news" is not a task; "summarize the Hacker News front page and my starred RSS feeds" is. Getting the noun right before the clock turned out to matter far more than I expected, because a scheduled agent that fires perfectly on time and produces mush is worse than no agent at all — it produces mush every morning forever.

The honest caveat. Exact alarms through Doze are an OS contract, and Android OEMs have a long, ugly history of quietly breaking that contract with their own battery optimizers. On my Fold it fires. On a device from a manufacturer that aggressively kills background work, your mileage may genuinely vary, and there is nothing an app can do about that beyond asking to be exempted. There's a smaller version of the same problem inside the app: if the exact-alarm permission isn't granted, or you're on a pre-Android-12 device, it falls back to an inexact alarm — it still fires, just not necessarily at 8:00:00. I'd rather say that plainly than pretend the schedule is bulletproof.

Where the results go

A notification is fine when you're holding the phone. It's useless when the point was that you weren't.

So the run result can be delivered somewhere that outlives the notification shade. An Obsidian draft, if you want it to land in your notes. Or straight out to Bluesky, Discord, Slack, Telegram, Mastodon, Misskey, or WordPress. Or to a generic webhook if you want to route it yourself.

What's actually proven. Bluesky is verified end to end — a scheduled agent fired, composed, and posted to a real account, no human in the loop. The other six social and publishing connectors ride the same dispatch code path and are wired the same way, but I have not individually fired each one against a live account yet. I'm telling you which one I watched work rather than listing seven and letting you assume.

The agents learned to remember

A scheduled agent that starts from zero every morning is a very expensive cron job. So there are three layers of memory now, and they're deliberately separate.

Execution memory is per-agent. The agent remembers what it produced last time and can recall it on the next run, so "summarize the news" can become "summarize what's new since yesterday" without you restating yesterday.

Skills are the layer I didn't expect to like as much as I do. When a multi-step run succeeds, the sequence gets saved as a recipe. The next time a similar task comes along, that recipe is reused automatically instead of the agent rediscovering the same five steps from scratch. It's the difference between an assistant who's been here a week and one who started this morning.

Shared memory is context visible to every agent, and it's the one I put a fence around. Writing to it requires an explicit trigger, and the write doesn't land until you confirm it. Cross-agent state that any agent can silently mutate is a great way to poison every agent at once, and you don't find out until every agent is already wrong.

Unattended mode is deliberately underpowered

This is the design decision I expect to get the most pushback on, so let me state it directly.

By default, an agent running unattended can only use Codex and local tools. It cannot reach for your Gemini key or your Perplexity key while you're asleep. If you want that, there's a setting called Autonomous Cloud; it's off by default, and you have to go turn it on yourself.

Outbound network calls can be routed through a capability broker with an egress allowlist — not a warning dialog, not a log line after the fact, but an allowlist the call has to pass before it leaves the device. Being straight about its status: the broker is a strangler seam that's live and enforced automatically whenever a run has touched untrusted, web-derived content, and available behind a flag otherwise. It is not yet the unconditional path for every outbound call. That's the next thing I want to close, not something I'm going to describe as finished.

The whole point of an autonomous agent is that it acts without asking, and every restriction I just described makes it feel less autonomous. I made the trade anyway. An unattended process holding your cloud credentials, running on a schedule you set three weeks ago and forgot about, with unrestricted network egress, is not a feature — it's a machine for turning one bad prompt into a bill and a data leak. I'd rather ship something that feels slightly reluctant and is safe to leave running.

The widget became a registration terminal

The Scouter widget from the last post was a monitor with a compose box. It showed you Codex state and let you send a prompt.

Then it grew a launchpad: one-tap RUN buttons for agents you'd already registered, right on the home screen, no app launch.

And then, most recently, it stopped being only a launchpad and became a registration point. You can type @agent ... directly into the widget's ASK box — or just talk to it — and register a brand-new agent from the home screen. It joins the exact same confirmation flow you'd get typing into the AI pane, same card, same wording, no separate half-implemented widget path to drift out of sync.

There's an opt-in setting called Widget No-Confirm Register, off by default, which skips the confirmation and registers immediately with a notification after the fact. It's scoped to commands that came from the widget — typing @agent in the AI pane still gets the card either way, so the escape hatch can't quietly widen into a global one. That one is for when you've done it fifty times and the card has become friction rather than a safeguard.

This is verified on-device, both states, including the behavioral difference between the setting on and off. Registering an agent that will wake the phone up tomorrow morning, from a widget, without opening the app, is my favorite thing in this release.

One CLI, many chats

Time for a correction that cuts against something I've said before.

The only first-class CLI integration now is Codex. A real CLI binary, running natively in the terminal. The Claude Code CLI and Gemini CLI integrations were removed. Claude Code is being brought back on a branch that hasn't merged, and I'm not going to be coy about why: claude -p still SIGSEGVs in its deep path, and I'm not shipping a CLI that segfaults so I can keep a longer feature list.

Meanwhile the AI pane went the other direction. Chat-style AI now reaches Gemini, Cerebras, Groq, Perplexity, OpenRouter (new), and local models through llama.cpp — Qwen3.5-2B Q4_K_M is what I actually use day to day on-device. You pick between them with an @mention mid-conversation.

The reorganization comes down to this: one CLI, made robust. Chat AI, given more options rather than fewer. Those two surfaces have completely different failure modes. A CLI that breaks takes your terminal with it. A chat backend that breaks means you @mention a different one and keep going.

Tabs are gone

The old UI was tabs. It isn't anymore.

Everything now lives in one ShellLayout: an AgentBar across the top, a Sidebar on the left, the pane container in the middle, and a ContextBar along the bottom showing cwd, git branch, and connection state. There are seven pane types — Terminal, Agent Chat, AI, Browser, Markdown, Preview, and Ask — and they split and resize freely, up to four at once on the unfolded display.

Tabs made sense when the terminal was the app and everything else was a detour. Once the agent, the chat, and the output preview all needed to be visible at the same time, tabs were just a way of hiding two-thirds of the work.

What I still can't do

Write production-grade Kotlin. Reason about AlarmManager's exact-alarm permission model without reading the docs three times and still getting it wrong once. Predict which OEM will decide my alarm is a battery threat.

What I can do is describe the shape of an autonomous system in plain English, insist on the safety fence before the feature, and refuse to ship the segfaulting one.

The agent used to be something I opened. Now it's something that opens by itself, at 8am, and tells me what it found.

GitHub: github.com/RYOITABASHI/Shelly — GPLv3. Issues, corrections, and "your alarm doesn't fire on my phone" reports are all genuinely welcome.

I Still Can't Write Code. But Now Codex Lives on My Home Screen and in a Split Pane — Same APK, No Termux.

RYO ITABASHI — Mon, 15 Jun 2026 13:25:31 +0000

Since the last post, the app grew into the OS.

The Problem I Kept Running Into

The last post solved the terminal problem: native PTY, zero IPC, tools in the APK.

But the AI was still a separate window. Switch apps to check Codex status. Copy errors, paste into ChatGPT. Unfold my Z Fold — layout broken.

Seven steps. Every single time.

So I told the agents: make the AI a first-class Android citizen.

What Changed

Before (v5.3):

AI runs in a terminal pane — works, but invisible when the app is closed
No widget, no home screen integration
Copy error → switch app → paste → read → switch back → paste fix → run
Z Fold cover → main display = layout glitch
Codex updates require full APK reinstall

After (v6.0):

Agent Chat pane reads Codex events live — approval cards, tool calls, session history — and runs fixes with one tap
Scouter widget on the home screen: quota bars, rate limits, cost, conversation preview — and send prompts directly from the widget
Codex Pets — avatars that cycle on the widget because why not
Per-category notification channels: approvals = Heads-up HIGH, errors = buzz, status = silent
Z Fold cover ↔ main display transitions = flawless
Codex runtime hot-swaps without touching the APK

Agent Chat — Zero Copy-Paste

The terminal AI now reads the terminal output automatically.

Codex throws an error. The Agent Chat pane shows it. You tap [Fix this]. Codex generates a command. You tap [Run]. The command lands in the terminal.

Seven steps → two taps.

Session history survives app restarts. Resume a previous Codex session from the sidebar. Rename it. See approval cards with accept/reject. All read-only, all live.

The copy-paste bridge is gone.

Scouter Widget — Codex on the Home Screen

The most requested feature: a real-time Codex dashboard on the Android home screen.

5-cell quota bar: green → yellow → critical red
Live rate-limit remaining, cost display, 60s heartbeat
Last user + Codex exchange shown in two lines
Send a prompt directly from the widget — tap the compose button, type, Codex executes in the background
Per-category notification channels — approvals get Heads-up priority, errors interrupt immediately, status updates stay quiet

I don't need to open Shelly to check if Codex is blocked on an approval anymore. It's on my home screen.

Codex Pets — Delight

If you're going to share your terminal with an AI all day, it should have a face.

Codex Pets are small overlay avatars on the widget. A dog. A cat. A robot. They cycle automatically. They do nothing functional. They make me smile.

Z Fold — The Hardest Bug

Foldables are two devices glued together. The cover display (904px portrait) and the main display (1812px landscape unfolded) trigger a full Android configuration change — and React Native does not handle that gracefully.

Three root-cause bugs:

The fold transition guard was silently blocking legitimate unfolds within 500ms of mount
onConfigurationChanged relayout was async-only — the pane container measured stale dimensions
A stale keyboard height persisted across the fold, pushing the layout offscreen

One with-saved-instance-state.js plugin patch, 15 AI-led debugging sessions, three TypeScript fixes.

Cover → main. Main → cover. No glitch.

By the Numbers

Metric	Before	After
CI build time	13m 53s	11m 45s
APK features	Terminal + AI panes	+ Agent Chat, Scouter Widget, Notification channels
Codex updates	Full APK reinstall	Hot-swap runtime updater
Z Fold	Broken	Fixed
Hidden panes	Buried in layout	Visible in Add sheet, promotion fixed

What I Still Can't Do

Write production-grade Kotlin. Ship a Jetpack Compose widget without an agent holding my hand. Understand Android's onConfigurationChanged lifecycle without 15 debugging sessions.

What I can do: describe a problem to Codex in plain English, watch it investigate, review its patch, and ship it.

The agent didn't just build the terminal anymore.

It became part of the OS.

Try It

GitHub: https://github.com/RYOITABASHI/Shelly

APK: GitHub Releases (android-latest)

License: GPLv3

Rough edges exist. That's why it's open source.

I Can't Write Code. But I Shipped a Native Android Terminal IDE with Claude Code + Codex Running Natively — No Termux Required.

RYO ITABASHI — Tue, 28 Apr 2026 14:07:07 +0000

Update: v0.1.0 Released

Since my last post, everything changed.

The WebView terminal is gone. Termux is no longer required.
Claude Code and Codex now run natively on Android —
in the same process as your shell, with zero TCP, zero IPC.

This is what shipped.

The Problem I Kept Running Into

Claude Code broke in Termux. Codex broke in Termux.
Every update was a gamble.

So I directed the AI to throw away the entire architecture
and rebuild it from scratch.

What Changed

Before (Plan A):

WebView terminal via ttyd
Termux required
TCP socket between terminal and app
Died every time I switched apps

After (Plan B):

Native PTY via JNI forkpty — same process, zero IPC, zero TCP
Termux not required
bash, Node.js, Python 3, git, curl, ripgrep, jq, tmux, vim, sqlite3 bundled inside the APK as .so files
Executed via /system/bin/linker64 to bypass SELinux's execve restrictions on app_data_file context

As far as I know, this is the only React Native app in the
world with an embedded native terminal emulator running
in-process via JNI.

Claude Code + Codex on Android

Both now run natively through Shelly's managed runtime:

Claude Code 2.1.125 (Opus 4.7, 1M context) ✅
Codex v0.124.0-termux (GPT-5.5) ✅
Gemini CLI 0.39.1 ✅

The runtime hot-swaps updates without an APK rebuild.
Broken versions are logged and cooled down automatically.

If Claude Code or Codex broke in your Termux setup —
this is the maintained path.

4 live panes simultaneously:

Top left: Claude Code terminal
Top right: Codex (GPT-5.5)
Bottom left: Cerebras AI pane with READING TERMINAL
Bottom right: Browser pane with YouTube

What Works Today

Native terminal with inline command blocks
Multi-pane layout (up to 4 live panes)
Cross-pane intelligence — AI reads terminal output automatically
Multi-agent routing: Claude, Gemini, Cerebras, Groq, Perplexity, Codex, Local LLM via llama.cpp
File editing with per-hunk InlineDiff accept/reject
@team multi-model consensus
SSH profiles
CRT mode (scanlines + phosphor green + vignette)

Known Limitations

Claude Code first-run OAuth requires credential transplant
Ports monitor blocked by Android 10+ SELinux (bug #99)
Test coverage is thin

Try It

GitHub: https://github.com/RYOITABASHI/Shelly

APK: GitHub Releases

License: GPLv3

Rough edges exist. That's why it's open source.

I Can't Write Code. But I Built a 100,000-Line Terminal IDE on My Phone.

RYO ITABASHI — Sat, 04 Apr 2026 16:35:18 +0000

I can't write code.

I'm not an engineer. I've never written a line of TypeScript. I have no formal training in computer science.

But I built a 100,000-line terminal IDE — by talking to AI.

Every architectural decision is mine. The code is not. It was created through conversation with Claude Code, running inside Termux on a Samsung Galaxy Z Fold6. No desktop. No laptop. Just a foldable phone and an AI that can execute commands.

Today I'm releasing it as open source.

GitHub: github.com/RYOITABASHI/Shelly

The Problem

You're running Claude Code in the terminal. It throws an error. You copy it. You switch to ChatGPT. You paste. You ask "what went wrong?" You copy the fix. You switch back. You paste. You run it.

Seven steps. Every single time.

The terminal and the chat live in different worlds. You are the copy-paste bridge between them.

The Solution

Shelly puts Chat and Terminal side by side — and connects them with AI.

Say "fix the error on the right". Shelly reads the terminal output, understands the error, and generates an executable command. Tap ▶ Run and the fix lands directly in the Terminal.

No copy. No paste. No tab switching.

What makes it different

Native terminal emulator. Not a WebView. Kotlin code derived from Termux's terminal-emulator library, rendering on an Android Canvas. Connected via a C helper (forkpty()) over TCP localhost. As far as I know, this is the only React Native app with an embedded native terminal emulator.

12 AI agents. @claude, @gemini, @codex, @cerebras, @local, @perplexity, @team, @plan, @arena, @actions. The input router automatically selects the best AI for the task, or you choose with @mentions.

It runs on your phone. Not in the cloud. Not on a desktop. Shelly + Termux gives you a full development environment in your pocket.

Key Features

Cross-pane intelligence — AI reads terminal output, suggests fixes, one-tap execution
ActionBlock — Code blocks in AI responses have [▶ Run] buttons
Approval Proxy — Terminal [Y/n] prompts become native chat buttons
Auto-savepoint — Game-like save system. Every change auto-committed. Revert with one tap.
Plan Mode — AI generates step cards. Execute or skip each step.
Arena Mode — Same prompt, two AIs, blind comparison. Vote for the better one.
Click-to-Edit — Tap any element in the preview panel, tell the AI what to change
VoiceChain — Speak → execute → TTS response. Hands-free development.
GitHub integration — AI suggests when to push. @actions sets up CI/CD without YAML.
5-level command safety — Every command is risk-assessed before execution
Local LLM support — Run models on-device via llama.cpp. Fully offline capable.

The keyboard too

The keyboard you see in the screenshots is Nacre — an 11,000-line Android IME I built (also through AI) to solve the input problem on mobile.

github.com/RYOITABASHI/Nacre

Built with

Layer	Technology
Framework	Expo 54 / React Native 0.81
Language	TypeScript + Kotlin + C
Terminal	Native emulator (Termux-derived) + Direct PTY (C, forkpty)
State	Zustand
i18n	900+ keys, English/Japanese

Why I built this

I'm a creative director. I wanted to use Claude Code on my phone, but Termux was too intimidating. So I made a chat interface that hides the complexity while keeping the full power.

Then I realized the real problem wasn't the terminal — it was the gap between the terminal and the AI. So I connected them.

Then the WebView kept dying every time I switched apps. So I directed the AI to replace the entire rendering layer with a native terminal emulator written in Kotlin and C.

100,000 lines later, I still can't write code. But I can describe what I need, and the AI builds it.

Try it

GitHub: github.com/RYOITABASHI/Shelly

APK: GitHub Releases

GPL v3. Built entirely on a Samsung Galaxy Z Fold6, in Termux, without ever touching a desktop computer.

Feedback, issues, and PRs welcome.