DEV Community: zohayr slileh

Chalkboard and avatar for ai agents

zohayr slileh — Sun, 04 Oct 2026 03:04:37 +0000

Because I find it difficult to read the textual output of agents after each modification or planning, and relate everything to the big picture, I built this simple application (with the help of Claude Code).

It is an Electron application that has an integrated terminal linked to the Chalkboard. Any agent you run in this terminal can use it and express its textual outputs in graphics that are easier to review.

Some may find the sounds a little annoying, but it's just an adjustable option, which I prefer.

Using it may cause a bit more token consumption or subscription quota, but in my experience with Claude Code I haven't seen a noticeable difference.

In general, the project is open source for anyone who wants to try it or modify it.

https://github.com/zohayrslileh/more-space

I spent six months building PhreshOS, an open-source system for web apps

zohayr slileh — Fri, 02 Oct 2026 08:57:04 +0000

Hello everyone, I want to share my experience over the past six months building an open-source web application system (with the help of Cloud Code and Codex). The system is real, not just a UI; everything you see here was built as an application on top of the system and is not part of it. Plus, it continues to work even if you close the browser (unlike Puter, for example).

source

https://github.com/PhreshOS/system

demo (around 5 people at a time, if it's full there's a timer)

https://demo.phreshos.com/

docs

https://phreshos.com/docs

how can I benefit from it? I build all my own tools on top of it, thus benefiting from remote access, a single authentication system, and communication. All I write is the business logic and how the interface will look. Any AI agent can access and use this application without me having to build a custom interface for it.

AI is no longer just a tool.

zohayr slileh — Fri, 02 Oct 2026 01:54:34 +0000

Many people still cling to the idea that artificial intelligence is merely a tool in the hands of the developer (this definition might have been acceptable a year or two ago), but the situation is different now. To demonstrate that it's more than just a tool, let's define the concept of a tool.

A tool is an extension of humanity itself; every action it takes stems from human action, and the quality of its results is directly linked to the quality of its use. It will typically malfunction or become less useful if it deviates from its intended purpose.

However, when a tool becomes capable of reframing the problem it solves, changing the direction of the solution itself, or perhaps even redefining the framework, the gap between the user's objective and the nature of the outcome begins to widen. I'm not claiming that AI will be able to act autonomously, but the need for precise guidance is diminishing daily.

Remember GPT-3? How bad it was at writing even the simplest code! It required at least three attempts to get it working. Aside from the training mechanisms and technologies that have evolved, the most crucial thing it lacked was data itself. The internet today is full of tutorials on how to use AI and get the best results, but what we often overlook is that AI itself learns from this knowledge and follows these methods and rules on its own.

For example, in the past, when you asked one model to write a prompt for another, it would often be confused because it didn't understand what those prompts meant or what it meant to instruct a language model. These concepts simply weren't part of its training. The same applies to things AI doesn't know today; it simply hasn't had enough exposure to them.

Therefore, in any course that teaches you how to do things AI can't do, remember that you and AI are, at this moment, classmates.

That's why I see AI today as more than just a tool; it's more like a partner, at least for now.

I spent 6 months building a real operating system for web apps

zohayr slileh — Wed, 30 Sep 2026 16:26:15 +0000

For the last six months or so I've been building something a bit unusual: a real operating system for web apps.

It's called PhreshOS. It's open source (MIT), and you can try a live demo right now: https://demo.phreshos.com/

I want to explain what it is, because "OS for web apps" can mean a lot of things.

The idea

PhreshOS is a programmable system that runs on your machine, with a desktop you open in the browser. You can reach it from anywhere you can reach your machine.

The apps on it (I call them Programs) are built with normal web tools. TypeScript, React if you want it, Vite, whatever you already use.

The difference is where you build them. You build a Program inside the System, and the System takes care of the parts every app has to redo:

sign-in and sessions
communication between the app's parts, and between apps
windows, storage, permissions

So you only write the app's own logic.

And everything you see on the desktop is a Program built on top of the System. The file manager, the settings, the wallpaper. None of it is baked into the core.

What a Program looks like

A Program has two sides: a Server that runs in the background, and a Client that shows up in a window.

Here's the counter you get when you create a new Program. The Server keeps the count:

import { context } from "@phreshos/server"

let count = 0

context.answer("read", () => count)

context.subscribe("increment", () => {
  count += 1
  context.publish("changed", count)
})

The Client asks for it, and follows the changes:

import { context } from "@phreshos/client"

const count = await context.server.ask<number>("read")
context.server.subscribe("changed", render)
context.server.publish("increment")

That's it. No HTTP routes, no WebSocket setup, no auth middleware. ask gets one answer, publish announces something, subscribe listens. The same three work between the two sides of a Program, between Programs, and from outside.

Built for agents first

This is the part I care about most.

On most systems, when an AI agent needs to use an app, it has to drive a browser and click buttons that were designed for eyes. Or someone writes a separate API just for the agent.

In PhreshOS, an agent uses the same apps you do, directly. The phresh command line reaches the whole running System, not just the install. So the agent you already use in your terminal can do things like:

phresh program list --json                  # what's installed
phresh process create --program files --name main   # open an app, its window appears on your desktop
phresh window maximize --process main --program files
phresh system logs --statement "select level, content from logs order by createdAt desc limit 10" --json

And it can call an app's features, the same ones the app's window uses:

phresh endpoint ask --program notes --process main --endpoint server --event notes.list --json

You don't design a special interface for the agent. If a feature exists for the window, it exists for the agent. phresh describe --all --json gives the agent every command as data, so it can find its own way around.

Try it

You need Node.js 24.15 or newer:

npm install --global @phreshos/cli
phresh system install

Then open the address it prints (usually http://localhost:4300) and create your account. You can also run it in a GitHub Codespace.

To build your first Program:

phresh create my-program
cd my-program
phresh dev

Its window opens on your desktop.

I've tested it on macOS and Linux. Windows, honestly, I don't know yet. If you try it there, I'd love to hear how it goes.

Lumiana — building personal apps with browser and Node.js APIs together

zohayr slileh — Sun, 06 Sep 2026 02:11:46 +0000

I've been working on Lumiana because I wanted to write a personal app's UI and logic together, without building a separate API just to connect them.

It works with Vite. You connect to the Node server with credentials first, then use Node imports alongside your UI code. JavaScript stays in the browser where possible, while operations that need the operating system run on the server.

After connecting, a small example looks like this:

import { hostname, platform } from 'node:os';

document.body.textContent = `Connected to ${hostname()} on ${platform()}`;

The goal is to use existing Node libraries as they are, without changing them or writing compatibility code for each package.

I've had examples running with Express, Hono, Elysia, Sharp, node-pty, and sqlite3, but it's still early. Most libraries I've tried don't work normally yet, so there's a lot left to do.

GitHub project and setup instructions