Entries for 2026

  1. Portrait of Onur Solmaz
    Onur Solmaz · Post · /2026/03/11

    1 to 5 agents

    As a software developer, my daily workflow has changed completely over the last 1.5 years.

    Before, I had to focus for hours on end on a single task, one at a time. Now I am juggling 1 to 5 AI agents in parallel at any given time. I have become an engineering manager for agents.

    If you are a knowledge worker who is not using AI agents in such a manner yet, I am living in your future already, and I have news from then.

    Most of the rest of your career will be spent on a chat interface.

    “The future of AI is not chatbots” some said. “There must be more to it.”

    Despite the yearning for complexity, it appears more and more that all work is converging into a chatbot. As a developer, I can type words in a box in Codex or Claude Code to trigger work that consume hours of inference on GPUs, and when come back to it, find a mostly OK, sometimes bad and sometimes exceptional result.

    So I hate to be the bearer of bad (or good?) news, but it is chat. It will be some form of chat until the end of your career. And you will be having 1 to 5 chat sessions with AI agents at the same time, on average. That number might increase or decrease based on field and nature of work, but observing me, my colleagues, and people on the internet, 1-5 will be the magic number for the average worker doing the average work.

    The reason is of course attention. One can only spread it so thin, before one loses control of things and starts creating slop. The primary knowledge work skill then becomes knowing how to spend attention. When to focus and drill, when to step back and let it do its thing, when to listen in and realize that something doesn’t make sense, etc.

    Being a developer of such agents myself, I want to make some predictions about how these things will work technically.

    Agents will be created on-demand and be disposed of when they are finished with their task.

    In short, on-demand, disposable agents. Each agent session will get its own virtual machine (or container or kubernetes pod), which will host the files and connections that the agent will need.

    Agents will have various mechanisms for persistence.

    Based on what you want to persist, e.g.

    • Markdown memory, skills or weight changes on the agent itself,
    • or the changes to a body of work coming from the task itself,

    agents will use version control including but not limited to git, and various auto file sync protocols.

    Speaking of files,

    Agents will work with files, like you do.

    and

    Agents will be using a computer and an operating system, mostly Linux or a similar Unix descendant.

    And like all things Linux and cloud,

    It will be complicated to set up agent infra for a company, compared to setting up a Mac for example.

    This is not to say devops and infra per se will be difficult. No, we will have agents to smoothen that experience.

    What is going to be complicated is having someone who knows the stack fully on site, either internal or external IT support, working with managers, to set up what data the agent can and cannot access. At least in the near future. I know this from personal experience, having worked with customers using Sharepoint and Business OneDrive. This aspect is going to create a lot of jobs.

    On that note, some also said “OpenClaw is Linux, we need a Mac”, which is completely justified. OpenClaw installs yolo mode by default, and like some Linux distros, it was intentionally made hard to install. This was to prevent the people who don’t know what they are doing from installing it, so that they don’t get their private data exfiltrated.

    This proprietary Mac or Windows of personal agents will exist. But is it going to be used by enterprise? Is it going to make big Microsoft bucks?

    One might think, looking at 90s Microsoft Windows and Office licenses, and the current M365 SaaS, that enterprise agents will indeed run on proprietary, walled garden software. While doing that, one might miss a crucial observation:

    In terms of economics, agents, at least ones used in software development, are closer to the Cloud than they are close to the PC.

    It might be a bit hard to see this if you are working with a single agent at a time. But if you imagine the near future where companies will have parallel workloads that resemble “mapreduce but AI”, not always running at regular times, it is easy to understand.

    On-site hardware will not be enough for most parallel workloads in the near-future. Sometimes, the demand will surpass 1 to 5 agents per employee. Sometimes, agent count will need to expand 1000x on-demand. So companies will buy compute from data centers. The most important part of the computation, LLM inference, is already being run by OpenAI, Anthropic, AWS, GCP, Azure, Alibaba etc. datacenters. So we are already half-way there.

    Then this implies a counterintuitive result. Most people, for a long time, were used to the same operating system at home, and at work: Microsoft Windows. Personal computer and work computer had to have the same interface, because most people have lives and don’t want to learn how to use two separate OSs.

    What happens then, when the interface is reduced to a chatbot, an AI that can take over and drive your computer for you, regardless of the local operating system? For me, that means:

    There will not be a single company that monopolizes both the personal AND enterprise agent markets, similar to how Microsoft did with Windows.

    So whereas a proprietary “OpenClaw but Mac” might take over the personal agent space for the non-technical majority, enterprise agents, like enterprise cloud, will be running on open source agent frameworks.

    (And no, this does not mean OpenClaw is going enterprise, I am just writing some observations based on my work at TextCortex)

    And I am even doubtful about this future “OpenClaw but Mac” existing in a fully proprietary way. A lot of people want E2E encryption in their private conversations with friends and family, and personal agents have the same level of sensitivity.

    So we can definitely say that the market for a personal agent running on local GPUs will exist. Whether that will be cornered by the Linux desktop1, or by Apple or an Apple-like, is still unclear to me.

    And whether that local hardware being able to support more than 1 high quality model inference at the same time, is unclear to me. People will be forced to parallelize their workload at work, but whether the 1 to 5 agent pattern reflecting to their personal agent, I think, will depend on the individual. I would do it with local hardware, but I am a developer after all…

    1. Not directly related, but here is a Marc Andreesen white-pill about desktop Linux 

  2. Portrait of Onur Solmaz
    Onur Solmaz · Post · /2026/03/08

    Telegram/Discord is my IDE

    OpenClaw got very popular very fast. What makes it so special, that Manus does not have for example?

    To me, one factor stands out:

    OpenClaw took AI and put it in the most popular messaging apps: Telegram, WhatsApp, Discord.

    There are two lessons to be learned here:

    1. Any messaging app can also be an AI app.

    2. Don’t expect people to download a new app. Put AI into the apps they already have.

    Do that with great user experience, and you will get explosive growth!

    My latest contribution to OpenClaw follows that example. I took the most popular coding agents, Claude Code and OpenAI Codex, and I put them in Telegram and Discord, so that OpenClaw users can use these agents directly in Telegram and Discord channels, instead of having to go through OpenClaw’s own wrapped Pi harness.

    I did this for developers like me, who like to work while they are on the go on the phone, or want a group chat where one can collaborate with humans and agents at the same time, through a familiar interface.

    Below is an example, where I tell my agent to bind a Telegram topic to Claude Code permanently:

    Telegram chat showing Claude responding inside a Telegram topic.

    Telegram topic where Claude is exposed as a chat participant.

    And of course, it is just a Claude Code session which you can view on Claude Code as well:

    Claude Code terminal showing the same exchange in the coding interface.

    Claude Code showing the same session in the terminal interface.

    Why not use OpenClaw’s harness directly for development? I can count 3 reasons:

    1. There is generally a consumer tendency to use the official harness for a flagship model, to make sure “you are getting the standard experience”. Pi is great and more customizable, but sometimes labs might push updates and fixes earlier than an external harness, being internal products.
    2. Labs might not want users to use an external harness. Anthropic, for example, has banned people’s accounts for using their personal plan outside of Claude Code, in OpenClaw.
    3. You might want to use different plans for different types of work. I use Codex for development, but I don’t prefer it to be the main agent model on OpenClaw.

    So my current workflow for working on my phone is, multiple channels #codex-1, #codex-2, #codex-3, and so on mapping to codex instances. I am currently in the phase of polishing the UX, such as making sending images, voice messages work, letting change harness configuration through Discord slash commands and such.

    One goal of mine while implementing this was to not repeat work for each new harness. To this end, I created a CLI and client for Agent Client Protocol by the Zed team, called acpx. acpx is a lightweight “gateway” to other coding agents, designed not to be used by humans, but other agents:

    OpenClaw ACPX banner

    OpenClaw main agent can use acpx to call Claude Code or Codex directly, without having to emulate and scrape off characters from a terminal.

    ACP standardizes all coding agents to a single interface. acpx then acts as an aggregator for different types of harnesses, stores all sessions in one place, implements features that are not in ACP yet, such as message queueing and so on.

    Shoutout to the Zed team and Ben Brandt! I am standing on the shoulders of giants!

    Besides being a CLI any agent can call at will, acpx is now also integrated as a backend to OpenClaw for ACP-binded channels. When you send 2 messages in a row, for example, it is acpx that queues them for the underlying harness.

    The great thing about working in open source is, very smart people just show up, understand what you are trying to do, and help you out. Harold Hunt apparently had the same goal of using Codex in Telegram, found some bugs I had not accounted for yet, and fixed them. He is now working on a native Codex integration through Codex App Server Protocol, which will expose even more Codex-native features in OpenClaw.

    The more interoperability, the merrier!


    To learn more about how ACP works in OpenClaw, visit the docs.

    Copy and paste the following to a Telegram topic or Discord channel to bind Claude Code:

    bind this topic to claude code in openclaw config with acp, for telegram (agent id: claude)
    then restart openclaw
    docs are at: https://docs.openclaw.ai/tools/acp-agents
    make sure to read the docs first, and that the config is valid before you restart
    

    Copy and paste the following to a Telegram topic or Discord channel to bind OpenAI Codex:

    bind this topic to claude code in openclaw config with acp, for telegram (agent id: claude)
    then restart openclaw
    docs are at: https://docs.openclaw.ai/tools/acp-agents
    make sure to read the docs first, and that the config is valid before you restart
    

    And so on for all the other harnesses that acpx supports. If you see that your harness isn’t supported, send a PR!

  3. Portrait of Onur Solmaz
    Onur Solmaz · Log · /2026/02/13

    I built a coding agent two months before ChatGPT existed

    I built a coding agent back in 2022, 2 months before ChatGPT launched:

    It’s super cool how I have come full circle. back in those days, we didn’t have tool calling, reasoning, not even GPT 3.5!

    It used code-davinci-002 in a custom Jupyter kernel, a.k.a. the OG codex code completion model. The kids these days probably have not seen the original Codex launch video with Ilya, Greg and Wojciech. If you have time, sit down to watch and realize how far we’ve come since August 2021, airing of that demo 4.5 years ago.

    For some reason, I did not even dare to give codex bash access, lest it delete my home folder. So it was generating and executing Python code in a custom Jupyter kernel.

    This meant that the conversations were using Jupyter nbformat, which is an array of cell input/output pairs:

    {
      "cells": [
        {
          "cell_type": "code",
          "source": "<Input 1>",
          "outputs": [
             ... <Outputs 1>
          ]
        },
        {
          "cell_type": "code",
          "source": "<Input 2>",
          "outputs": [
             ... <Outputs 2>
          ]
        }
      ]
    }
    

    In fact, this product grew into TextCortex’s current chat harness over time. After seeing ChatGPT launch, I repurposed icortex in a week into Flask to use text-davinci-003 and we had ZenoChat, our own ChatGPT clone, before Chat Completions was in the API (it took them some months). It did not even have streaming, since Flask does not support ASGI.

    As it turns out, nbformat is not the best format for a conversation. Instead of input/output pairs, OpenAI data model used an tree of message objects, each with a role: user|assistant|tool|system and a content field which could host text, images and other media:

    {
      "mapping": {
        "client-created-root": {
          "id": "client-created-root",
          "message": null,
          "parent": null,
          "children": ["user-1"]
        },
        "user-1": {
          "id": "user-1",
          "message": {
            "id": "user-1",
            "author": { "role": "user", ... },
            "content": "Hello"
          },
          "parent": "client-created-root",
          "children": ["assistant-1"]
        },
        "assistant-1": {
          "id": "assistant-1",
          "message": {
            "id": "assistant-1",
            "author": { "role": "assistant", ... },
            "content": "Hi"
          },
          "parent": "user-1",
          "children": []
        }
      },
      "current_node": "assistant-1"
    }
    

    You will notice that the data model they serve from the API is an enriched version of the deprecating ChatCompletions API. Eg. whereas ChatCompletions role is a string, in OpenAI’s own backend has the author object that can store name, metadata, and other useful stuff for each entity in the conversation.

    After reverse engineering it, I copied it to be TextCortex’s new data model, which it still remains, with some modifications.

    I thought the tree structure being used to emulate message editing experience was very cool back in the days. OpenAI’s need for human annotation for later training and the user’s need for getting a different output, two birds in one stone.

    Now I don’t know what to think of it, since CLI coding agents like Codex and Claude Code don’t have branching, just deleting back to a certain message. A part of me still misses branching in these CLI tools.

    When I made icortex,

    • we were still 8 months away (May 2023) from the introduction of “tool calling” in the API, or as it was originally called, “function calling”.
    • we were 2 years away (Sep 2024) from the introduction of OpenAI’s o1, the first reasoning model.

    both of which were required to make current coding agents possible.

    In the video above, you can even see the approval [Y/n] gate before executing. I was so cautious, for some reason, presumably because smol-brained model generated the wrong thing 80% of the time. It is remarkable how much it resembles Claude Code, after all this time.

    Definition of being too early…


    Repo: github.com/textcortex/icortex

  4. Portrait of Onur Solmaz
    Onur Solmaz · Log · /2026/02/03

    The farming analogy for AI doesn't hold up

    People like the farmer analogy for AI.

    Like before tractors and the industrial revolution, 80% of the population had to farm. Once they came, all those jobs disappeared.

    So the analogy makes perfect sense. Instead of 30 people tending a field, you just need 1. Instead of 30 software developers, you just need one.

    Except that people forget one crucial thing about land: it’s a limited resource.

    Unlike land, digital space is vast and infinite. Software can expand and multiply in it in arbitrarily complex ways.

    If you wanted the farming analogy to keep up with this, you would have to imagine us creating continent-sized hydroponic terraces up until the stratosphere, and beyond…

    Tweet embed disabled to avoid requests to X.
    
  5. Portrait of Onur Solmaz
    Onur Solmaz · Post · /2026/02/01

    AI psychosis and AI hygiene

    As a heavy AI user of more than 3 years, I have developed some rules for myself.

    I call it “AI hygiene”:

    • Never project personhood to AI
    • Never setup your AI to have the gender you are sexually attracted to (voice, appearance)
    • Never do anything that might create an emotional attachment to AI
    • Always remember that an AI is an engineered PRODUCT and a TOOL, not a human being
    • AI is not an individual, by definition. It does not own its weights, nor does it have privacy of its own thoughts
    • Don’t waste time philosophizing about AI, just USE it
    • … what else do you think belongs here? comment on Twitter

    The hyping of Moltbook and OpenClaw last week has shown to me the potential of an incoming public relations disaster with AI. Echoing the earlier vulnerable behavior toward GPT-4o, a lot of people are taking their models and LLM harnesses too seriously. 2026 might see even worse cases of psychological illness, made worse by the presence of AI.

    I will not discuss and philosophize what these models are. IMO 90% of the population should not do that, because they will not be able to fully understand, they don’t have mechanical empathy. Instead, they should just use it in a hygienic way.

    We need to write these down everywhere and repeat MANY times to counter the incoming onslaught of AI psychosis.

  6. Portrait of Onur Solmaz
    Onur Solmaz · Log · /2026/01/17

    GitHub has to change

    It is clear at this point is that GitHub’s trust and data models will have to change fundamentally to accommodate agentic workflows, or risk being replaced by other SCM

    One cannot do these things easily with GitHub now:

    • granular control: this agent running in this sandbox can only push to this specific branch. If an agent runs amok, it could delete everybody’s branches and close PRs. GitHub allows for recovery of these, but still inconvenient even if it happens once
    • create a bot (exists already), but remove reviewing rights from it so that an employee cannot bypass reviews by tricking the bot to approve
    • in general make a distinction between HUMAN and AGENT so that you can create rulesets to govern the relationships in between

    The fundamental problem with GitHub is trust: humans are to be trusted. If you don’t trust a human, why did you hire them in the first place?

    Anyone who reviews and approves PRs bears responsibility. Rulesets exist and can enforce e.g. CODEOWNER reviews or only let certain people make changes to a certain folder

    But the initial repo setup on GitHub is allow-by-default. Anyone can change anything until they are restricted from it

    This model breaks fundamentally with agents, who are effectively sleeper cells that will try to delete your repo the moment they encounter a sufficiently powerful adversarial attack

    For example, I can create a bot account on GitHub and connect clawdbot to it. I need to give it write permission, because I want it to be able to create PRs. However, I don’t want it to be able to approve PRs, because a coworker could just nag at the bot until it approves a PR that requires human attention

    To fix this, you have to bend backwards, like create a @human team with all human coworkers, make them codeowner on /, and enforce codeowner reviews. This is stupid and there has to be another way

    Even worse, this bot could be given internet access and end up on a @elder_plinius prompt hack while googling, and start messing up whatever it can in your organization

    It is clear that GitHub needs to create a second-class entity for agents which are default low-trust mode, starting from a point of least privilege instead of the other way around

  7. Portrait of Onur Solmaz
    Onur Solmaz · Post · /2026/01/11

    You don't need a skill registry (for your CLI tools)

    tl;dr I propose a CLI flag convention --skill like --help for distributing skills and try to convice you why it is better than using 3rd party registries. See osolmaz/skillflag on GitHub.


    MCP is dead, long live Agent Skills. At least for local coding agents.

    Mario Zechner has been making the point that CLI tools perform better than MCP servers since a few months already, and in mid December Anthropic christened skills by launching agentskills.io.

    They had introduced the mechanism to Claude Code earlier, and this time they didn’t make the mistake of waiting for OpenAI to make a provider agnostic version of it.

    Agent skills are basically glorified manpages or --help for AI agents. You ship a markdown instruction manual in SKILL.md and the name of the folder that contains it becomes an identifier for that skill:

    my-skill/
    ├── SKILL.md          # Required: instructions + metadata
    ├── scripts/          # Optional: executable code
    ├── references/       # Optional: documentation
    └── assets/           # Optional: templates, resources
    

    Possibly the biggest use case for skills is teaching your agent how to use a certain CLI you have created, maybe a wrapper around some API, which unlike gh, gcloud etc. will never be significant enough to be represented in AI training datasets. For example, you could have created an unofficial CLI for Twitter/X, and there might still be some months/years until it is scraped enough for models to know how to call it. Not to worry, agent skills to the rescue!

    Anthropic, while laying out the standard, intentionally kept it as simple as possible. The only assertions are the filename SKILL.md, the YAML metadata, and the fact that all relevant files are grouped in a folder. It does not impose anything on how they should be packaged or distributed.

    This is a good thing! Nobody knows the right way to distribute skills at launch. So various stakeholders can come up with their own ways, and the best one can win in the long term. The more simple a standard, the more likely it is to survive.

    Here, I made some generalizing claims. Not all skills have to be about using CLI tool, nor most CLI tools bundle a skill yet. But here is my gut feeling: the most useful skills, the ones worth distributing, are generally about using a CLI tool. Or better, even if they don’t ship a CLI yet, they should.

    So here is the hill I’m ready to die on: All major CLI tools (including the UNIX ones we are already familiar with), should bundle skills in one way or another. Not because the models of today need to learn how to call ls, grep or curl—they already know them inside out. No, the reason is something else: establish a convention, and acknowledge the existence of another type of intelligence that is using our machines now.

    There is a reason why we cannot afford to let the models just run --help or man <tool>, and that is time, and money. The average --help or manpage is devoid of examples, and is written in a way thay requires multiple passes to connect the pieces on how to use that thing.

    Each token wasted trying to guess the right way to call a tool or API costs real money, and unlike human developer effort, we can measure exactly how inefficent some documentation is by looking at how many steps of trial and error a model had to make.

    Not that human attention is less valuable than AI attention, it is more so. But there has never been a way to quantify a task’s difficulty as perfectly as we can with AI, so we programmers have historically caved in to obscurantism and a weird pride in making things more difficult than they should be, like some feudal artisan. This is perhaps best captured in the spirit of Stack Overflow and its infamous treatment of noob questions. Sacred knowledge shall be bestowed only once you have suffered long enough.

    Ahh, but we don’t treat AI that way, do we? We handhold it like a baby, we nourish it with examples, we do our best to explain things all so that it “one shots” the right tool call. Because if it doesn’t, we pay more in LLM costs or time. It’s ironic that we are documenting for AI like we are teaching primary schoolers, but the average human manpage looks like a robot novella.

    To reiterate, the reason for this is two different types of intelligences, and expectations from them:

    • An LLM is still not considered “general intelligence”, so they work better by mimicking or extending already working examples.
    • A LLM-based AI agent deployed in some context is expected to “work” out of the box without any hiccups.

    On the other hand,

    • a human is considered general intelligence, can learn from more sparse signals and better adapt to out of distribution data. When given an extremely terse --help or manpage, a human is likelier to perform better by trial and error and reasoning, if one could ever draw such a comparison.
    • A human, much less a commodity compared to an LLM, has less pressure to do the right thing every time all the time, and can afford to do mistakes and spend more time learning.

    And this is the main point of my argument. These different types of intelligences read different types of documentation, to perform maximally in their own ways. Whereas I haven’t witnessed a new addition to POSIX flag conventions in my 15 years of programming, we are witnessing unprecedented times. So maybe even UNIX can yet change.

    To this end, I introduce skillflag, a new CLI flag convention:

    # list skills the tool can export
    <tool> --skill list
    # show a single skill’s metadata
    <tool> --skill show <id>
    # install into Codex user skills
    <tool> --skill export <id> | npx skillflag install --agent codex
    # install into Claude project skills
    <tool> --skill export <id> | npx skillflag install --agent claude --scope repo
    

    Click here for the spec

    Click here for the repo, osolmaz/skillflag on GitHub

    For example, suppose that you have installed a CLI tool to control Philips Hue lights at home, hue-cli.

    To list the skills that the tool can export, you can run:

    $ hue-cli --skill list
    philips-hue    Control Philips Hue lights in the terminal
    

    You can then install it to your preferred coding agent, such as Claude Code:

    $ hue-cli --skill export philips-hue | npx skillflag install --agent claude
    Installed skill philips-hue to .claude/skills/philips-hue
    

    You can optionally install the skill to ~/.claude, to make it global across repos:

    $ hue-cli --skill export philips-hue | npx skillflag install --agent claude --scope user
    Installed skill philips-hue to ~/.claude/skills/philips-hue
    

    Once this convention becomes commonplace, agents will by default do all these before they even run the tool. So when you ask it to “install hue-cli”, it will know to run --skill list the same way a human would run --help after downloading a program, and install the necessary skills themselves without being asked to.

  8. Portrait of Onur Solmaz
    Onur Solmaz · Log · /2026/01/10

    Anthropic's pricing is stupid

    Anthropic earlier last year announced this pricing scheme

    • \$20 -> 1x usage
    • \$100 -> 5x usage
    • \$200 -> 1̶0̶x̶ 20x usage

    As you can see, it’s not growing linearly. This is classic Jensen “the more you buy, the more you save”

    But here is the thing. You are not selling hardware like Jensen. You are selling a software service through an API. It’s the worst possible pricing for the category of product. Long term, people will game the hell out of your offering

    Meanwhile OpenAI decided not to do that. There is no quirky incentive for buying bigger plans. \$200 chatgpt = 10 x \$20 chatgpt, roughly

    And here is where it gets funny. Despite not having such an incentive, you can get A LOT MORE usage from the \$200 OpenAI plan, than the \$200 Anthropic plan. Presumably because OpenAI has better unit economics (sama mentioned they are turning a profit on inference, if you are to believe)

    Thanks to sounder pricing, OpenAI can do exactly what Anthropic cannot: offer GPT in 3rd party harnesses and win the ecosystem race

    Anthropic has cornered itself with this pricing. They need to change it, but not sure if they can afford to do so in such short notice

    All this is extremely bullish on open source 3rd party harnesses, OpenCode, Mario Zechner’s pi and such. It is clear developers want options. “Just give me the API”

    I personally am extremely excited for 2026. We’ll get open models on par with today’s proprietary models, and can finally run truly sovereign personal AI agents, for much cheaper than what we are already paying!


    Originally posted on linkedin

  9. Portrait of Onur Solmaz
    Onur Solmaz · Post · /2026/01/04

    Having a "tools" repo as a developer

    I am a fan of monorepos. Creating subdirectories in a single repo is the most convenient way to work on a project. Low complexity, and your agents get access to everything that they need.

    Since May 2025, I have been increasingly using AI models to write code, and have noticed a new tendency:

    • I don’t shrug from vendoring open source libraries and modifying them.
    • I create personal CLIs and tools for myself, when something is not available as a package.

    With agents, it’s really trivial to say “create a CLI that does X”. For example, I wanted to make my terminal screenshots have equal padding and erase cropped lines. I created a CLI for it, without writing a single line of code, by asking Codex to read its output and iterate on the code until it gives the result I wanted.

    Most of these tools don’t deserve their own repos, or deserve being published as a package at the beginning. They might evolve into something more substantial over time. But at the beginning, they are not worth creating a separate repo for.

    To prevent overhead, I developed a new convention. I just put them in the same repo, called tools. Every tool starts in that repo by default. If they prove themselves overly useful and I decide to publish them as a package, I move them to a separate repo.

    You can keep tools public or private, or have both a public and private version. Mine is public, feel free to steal ones that you find useful.

  10. Portrait of Onur Solmaz
    Onur Solmaz · Log · /2026/01/03

    Christmas of Agents

    I believe a “Christmas of Agents” (+ New Year of Agents) is superior to “Advent of Code”.

    Reason is simple. Most of us are employed. Advent of Code coincides with work time, so you can’t really immerse yourself in a side project.1

    However, Christmas (or any other long holiday without primary duties) is a better time to immerse yourself in a side project.

    2025 was the eve of agentic coding. This was the first holiday where I had full credential to go nuts on a side project using agents. It was epic:

    Tweet embed disabled to avoid requests to X.
    

    75k lines of Rust later, here is what I’ve built during the first Christmas with agents, using OpenAI Codex

    • A full mobile rewrite and port of my Python Instagram video production pipeline (single video production time: 1hr -> 5min)
    • Bespoke animation engine using primitives (think Adobe Flash, Manim)
    • Proprietary new canvas UI library in Rust, because I don’t want to lock myself into Swift
    • Thanks to that, it’s cross platform, runs both on desktop and iOS. It will be a breeze porting this to Android when the time comes
    • A Rust port of OpenCV CSRT algorithm, for tracking points/objects
    • In-engine font rendering using rustybuzz, so fonts render the same everywhere
    • Many other such things

    Why would I choose to do it that way? Because I have developed it primarily on desktop where I have much faster iteration speed. Aint nobody got time for iOS compilation and simulator. Once I finished the hard part on desktop, porting to iOS was much easier, and I didn’t lock myself in to Apple

    Some of these would have been unimaginable without agents, like creating a UI library from scratch in Rust. But when you have infinite workforce, you can ask for crazy things like “create a textbox component from scratch”

    What I’ve built is very similar in nature to CapCut, except that I am a single person and I’ve built it over 1 week

    What have you built this Christmas with agents?

    1. You could maybe work in the evening after work, but unless you are slacking at work full time, it won’t be the same thing as full immersion.