<feed xmlns="http://www.w3.org/2005/Atom">
  <title>exe.dev</title>
  <subtitle>Blog</subtitle>
  <link href="https://blog.exe.dev/atom.xml" rel="self" />
  <link href="https://blog.exe.dev/" />
  <id>urn:uuid:5d91d8a1-21f2-4e33-8e5a-4dc963e837c5</id>
  <updated>2026-11-19T00:00:00Z</updated>
  
  <entry>
    <title>Hey Shelley, Fix My Monitor</title>
    <link href="https://blog.exe.dev/fix-my-monitor" />
    <id>https://blog.exe.dev/fix-my-monitor</id>
    <updated>2026-11-18T22:20:00Z</updated>
    <summary>All I wanted was for my monitor’s lights to stop blinking. Things got complicated.</summary>
    <content type="html">&lt;p&gt;Earlier this year, I was on the hunt for a new monitor. My old one was a 27” 4K (Dell U2720Q). I wanted something slightly bigger and ideally 5-6K. After doing a bit of research, I realized that my options were fairly limited. The Apple Pro Display XDR was pretty but 4x my budget. The Apple Studio Display was 5K and 27”, so it didn’t fit the bigger screen requirement. The Dell U3224KB was 2.5x my budget.&lt;/p&gt;
&lt;p&gt;But then I lucked out and found a brand new Dell U3224KB for ~$1,100 on Facebook Marketplace. I was so excited when I plugged it in, but then I realized it had a manufacturing issue where these lights would just continuously cycle on and off. I think the intent was for them to turn on when my hand was near them, but they’d turn off for a few seconds and then turn right back on. It was almost like a perpetual notification coming in and distracting me from my work. I stopped using the monitor for a few months.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/dell-u3224kb-lights.jpg&#34; alt=&#34;The touch buttons along the bottom edge of the Dell U3224KB, all lit: a phone button, volume down and volume up in white, and microphone mute and camera off in red.&#34; width=&#34;720&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;p&gt;Any reasonable person would have tried to contact Dell support and have them fix the issue. But the thought of going through their website and figuring out how to chat with them and not having the original receipt just didn’t feel like a good use of time. So I just continued using my laptop and feeling sad about my purchase.&lt;/p&gt;
&lt;p&gt;A few weeks ago, I saw that people were using agents to reverse-engineer and remove cruft from their smart TVs. That gave me the idea of asking Shelley to fix my monitor. After giving it access, I spun up a conversation with 6.1 Sol and gave it a video of the symptoms and asked it to figure out how to stop the lights from cycling without disabling the buttons.&lt;/p&gt;
&lt;p&gt;Sol was able to read the firmware from the monitor, disassemble it and propose a few fixes. Over the course of two days (mostly because I kept getting distracted with life and work), it attempted to flash a few fixes that didn’t take. Then Astra stepped in and tried a few as well until ultimately it did a bad firmware flash and the audio controller just stopped working entirely. Astra and Opus tried to fix the issue to no avail: the audio controller had entered DFU mode and would not accept updates. Every attempt put it in an error state. We even booted up a Windows VM to see if we could get the original firmware updater to fix the thing. That failed too. After a few attempts, I gave up.&lt;/p&gt;
&lt;p&gt;When I asked the agent, “What do I do now?” I got this response:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;I’m sorry, Maisem. You wanted an annoying light fixed, and my mistake left you with a broken audio controller. That’s on me.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;On the bright side, the lights completely went away. I was actually happier in this state. I didn’t particularly like the audio quality from the monitor anyway, and the lights were so distracting that the tradeoff was worth it.&lt;/p&gt;
&lt;p&gt;Then Fable 5.2 launched and I decided to see if it could recover the audio controller.&lt;/p&gt;
&lt;p&gt;Four minutes later, I got this:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Got it back. The monitor&#39;s audio/button controller is running again as the normal Dell device (not recovery mode). I loaded the original Dell firmware into its memory over USB.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;But how?!&lt;/p&gt;
&lt;p&gt;Turns out two things had to be true: the chip had to be freshly powered on, and the firmware had to be sent starting partway into Dell&#39;s file (offset 0x3000, the part the chip actually runs) instead of from the start. Apparently Astra had been trying to flash it incorrectly.&lt;/p&gt;
&lt;p&gt;So I told Fable to fix the lights. It correctly flashed the same firmware that Astra had built. The lights all went off, and the audio still worked. But now the buttons didn’t work correctly.&lt;/p&gt;
&lt;p&gt;So Fable restored the stock firmware, then followed it with a 2-byte change (as opposed to Astra’s 8-byte change) and that fixed the buttons not working. But now the lights remained on. This was arguably a great place to stop.&lt;/p&gt;
&lt;p&gt;But I did not do that. In fact, I thought, why not push the model further? I asked Fable to have the lights come on when I touch the panel and then fade out after 10 seconds. It had me press the buttons so that it could watch the events, and about 18 minutes later, it had added a new routine to the firmware which would reset a timer after every press and then fade out the lights. It worked beautifully.&lt;/p&gt;
&lt;p&gt;All this is to say that the AI models have gotten remarkably good and they can now do things that only a handful of people could do before. I could not have ever imagined doing something like this, but now it just took a few prompts. The possibilities are seemingly endless.&lt;/p&gt;
&lt;p&gt;PS: My wife and friends tell me that I could have used black tape to cover the blinking lights. But where’s the fun in that?&lt;/p&gt;
</content>
    <author>
      <name>Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Backup and Restore on exe.dev</title>
    <link href="https://blog.exe.dev/backup-restore" />
    <id>https://blog.exe.dev/backup-restore</id>
    <updated>2026-11-12T18:25:00Z</updated>
    <summary>Back up your exe.dev VMs to your own S3 bucket, incrementally, in an open format.</summary>
    <content type="html">&lt;p&gt;A common question we see on our Discord and in support is how to back up exe.dev VMs. We&#39;ve built a &lt;code&gt;backup&lt;/code&gt; command (and its good friend, the &lt;code&gt;restore&lt;/code&gt; command) to facilitate just that.&lt;/p&gt;
&lt;p&gt;We decided that the best place to store your backups is in your own S3 bucket. To set up backups, you first set up a WIF integration, granting us access to a bucket in S3. Our &lt;a href=&#34;https://exe.dev/docs/vm-backups&#34;&gt;documentation&lt;/a&gt; walks you through the steps, and I&#39;ll let you in on a secret: your coding agent is the best way to follow that documentation. Then run the backup command, and voilà.&lt;/p&gt;
&lt;div class=&#34;excalimux-anim&#34; data-src=&#34;/assets/vm-backups-to-s3.svg&#34; role=&#34;img&#34; aria-label=&#34;Animation: a backup snapshots the VM&#39;s disk, cuts it into 1 MB chunks, hashes each chunk, and uploads, compressed, only the chunks the S3 bucket doesn&#39;t already have under chunks/. It then writes an index from each disk offset to its chunk under indexes/. When the VM later writes, the next backup hashes the changed chunks and uploads only the missing ones, so backups are incremental.&#34;&gt;&lt;noscript&gt;&lt;img src=&#34;/assets/vm-backups-to-s3.svg&#34; alt=&#34;Animation: a backup snapshots the VM&#39;s disk, cuts it into 1 MB chunks, hashes each chunk, and uploads, compressed, only the chunks the S3 bucket doesn&#39;t already have under chunks/. It then writes an index from each disk offset to its chunk under indexes/. When the VM later writes, the next backup hashes the changed chunks and uploads only the missing ones, so backups are incremental.&#34;&gt;&lt;/noscript&gt;&lt;/div&gt;
&lt;script src=&#34;/assets/excalimux-player.js&#34; defer=&#34;&#34;&gt;&lt;/script&gt;
&lt;p&gt;Our backup format is the same as &lt;a href=&#34;https://github.com/systemd/casync&#34;&gt;Casync&lt;/a&gt; / &lt;a href=&#34;https://github.com/folbricht/desync&#34;&gt;Desync&lt;/a&gt;. In short, we take your disk, split it into 1 MB chunks, and hash those. We upload compressed chunks identified by hash to S3 (ignoring the ones that haven&#39;t changed), and upload an index of those chunks to represent the backup. A VM with a slow-changing disk might only need to update a few chunks at every backup iteration, which makes these backups incremental. Furthermore, because the format is open source, you can use existing tools to reconstruct your disk elsewhere, or even mount it in a lazy FUSE file system.&lt;/p&gt;
&lt;p&gt;Documentation at &lt;a href=&#34;https://exe.dev/docs/vm-backups&#34;&gt;exe.dev/docs/vm-backups&lt;/a&gt;. Give it a try!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Give Agents Temporary Access to Sensitive Integrations</title>
    <link href="https://blog.exe.dev/step-up-integrations" />
    <id>https://blog.exe.dev/step-up-integrations</id>
    <updated>2026-11-11T15:00:00Z</updated>
    <summary>Add an approval step so you know when agents access sensitive integrations. Grant access for 10 minutes, an hour, six hours, or a day.</summary>
    <content type="html">&lt;p&gt;Exe.dev integrations are a powerful primitive to give your VMs access to resources without giving agents the underlying secrets. For example, you can give your VM access to a GitHub repo without leaving your private key or personal access token on the VM, where an agent could potentially misuse it.&lt;/p&gt;
&lt;p&gt;If you want an extra layer of protection, you can configure your integration for &amp;quot;step up&amp;quot; mode. Then, when the VM tries to use the integration, it will return a link so you can approve access. Click on that link and approve it for some time period. This lets you keep an eye on your agents and grant temporary access to high-value integrations (e.g., access to prod).&lt;/p&gt;
&lt;p&gt;To use this, add an integration with &lt;code&gt;--stepup web&lt;/code&gt;:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;exe.dev ▶ int add http-proxy --name demo \
    --target https://httpbin.exe.xyz/ --bearer shhh \
    --stepup web --attach vm:drum-dragon
Added integration demo

Usage from a VM:
  ssh drum-dragon.exe.xyz curl https://demo.int.exe.xyz/
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;When you trigger the integration, you&#39;ll see an approval link:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;exe.dev ▶ ssh drum-dragon.exe.xyz curl https://demo.int.exe.xyz/
Integration &amp;#34;demo&amp;#34; needs approval:
       https://exe.dev/a/afvpfibvypeti2loorhfumrxj5cvoskjkfgvasv7rsp4l2ckxl6q
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;If you’re logged in, this will take you to a simple screen:&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/stepup-approve.png&#34; alt=&#34;Approval screen: VM drum-dragon is trying to use integration demo. Approve for 10m, 1h, 6h, or 1d, with Don&#39;t approve and Approve buttons.&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;Approve the integration for 10 minutes, an hour, six hours, or a day.&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;p&gt;This works for many of our integration types. Agents are excellent at prompting you to take the next step.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Download the exe.dev Mac App</title>
    <link href="https://blog.exe.dev/mac-app" />
    <id>https://blog.exe.dev/mac-app</id>
    <updated>2026-11-10T15:00:00Z</updated>
    <summary>You can now access exe.dev via the Mac app. Try it!</summary>
    <content type="html">&lt;p&gt;&lt;img src=&#34;/assets/1793147995-image.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Download the &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; Mac app at &lt;a href=&#34;https://exe.dev/mac&#34;&gt;https://exe.dev/mac&lt;/a&gt;. Users of &lt;a href=&#34;https://apps.apple.com/us/app/exe-dev/id6759881448&#34;&gt;the iOS app&lt;/a&gt; will find it a familiar place to manage all your VMs and all the Shelley conversations on those VMs, as well as a no-nonsense terminal.&lt;/p&gt;
&lt;p&gt;For those keeping track at home, you can access &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; via:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;code&gt;ssh exe.dev&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://exe.dev/&#34;&gt;The web&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://play.google.com/store/apps/details?id=dev.exe.android&amp;amp;hl=en_US&#34;&gt;The Android app&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://apps.apple.com/us/app/exe-dev/id6759881448&#34;&gt;The iOS app&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://exe.dev/mac&#34;&gt;The Mac app&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;We can’t tell you about #6 yet, but reach out if you’ve tried an AI personal assistant and thought, “but what if this actually worked?”&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;All the platforms have their trade-offs. I personally use four of the above daily to work on exe.dev as well as other projects. In other words, the number of platforms is not a Conway&#39;s Law reflection of exe.dev as a company, but rather a belief that good infrastructure pairs well with good tools. Several folks have built their own systems to manage their VMs and conversations; we are thrilled that people are &lt;a href=&#34;https://blog.exe.dev/devtools-must-be-open-source&#34;&gt;customizing software&lt;/a&gt; to fit their needs.&lt;/p&gt;
&lt;p&gt;I&#39;ll leave you with a video of using the app to record your screen:&lt;/p&gt;
&lt;div class=&#34;video-figure&#34;&gt;&lt;figure&gt;&lt;video controls=&#34;&#34; playsinline=&#34;&#34; preload=&#34;metadata&#34; width=&#34;1754&#34; height=&#34;1080&#34; poster=&#34;/assets/exe-dev-mac-app-demo-poster.jpg&#34;&gt;&lt;source src=&#34;/assets/exe-dev-mac-app-demo.mp4&#34; type=&#34;video/mp4&#34;&gt;&lt;/video&gt;&lt;/figure&gt;&lt;/div&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Agents Can Handle Billing, Actually</title>
    <link href="https://blog.exe.dev/pricing-changes-are-slow-ours-took-a-month" />
    <id>https://blog.exe.dev/pricing-changes-are-slow-ours-took-a-month</id>
    <updated>2026-11-09T18:50:00Z</updated>
    <summary>We let agents handle the billing code while we focused on what to charge.</summary>
    <content type="html">&lt;p&gt;Pricing changes are notoriously difficult. Billing code can spread throughout a system, with logic tied to plan names or specific prices. Even small tweaks can have unexpected side effects. I’ve seen teams spend years on a proposed pricing change, only to abandon it due to the technical complexity.&lt;/p&gt;
&lt;p&gt;We recently introduced a new pricing model. It took about a month to implement, with agents doing most of the heavy lifting. Our architecture made that possible. This was the first major pricing change to our billing framework, and we barely had to read the code.&lt;/p&gt;
&lt;p&gt;exe’s &lt;a href=&#34;https://blog.exe.dev/billable-facts&#34;&gt;billing layer&lt;/a&gt; is pretty simple. About 90 percent of our billing code follows this pattern:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A user action or runtime event changes something billable.&lt;/li&gt;
&lt;li&gt;We record that change as a fact in a database table.&lt;/li&gt;
&lt;li&gt;A reconciler worker sweeps the table, applies business logic and validation, and calculates a billable quantity.&lt;/li&gt;
&lt;li&gt;We submit that quantity to Stripe, where it becomes a line item on an invoice.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Half of the remaining code handles subscriptions and collecting payment information—a textbook Stripe implementation. The other half handles LLM credits and yak shaving. Some yaks may not even be yaks. More on this in a later post.&lt;/p&gt;
&lt;p&gt;As exe’s billing system has grown, it’s stayed a sleepy process that anyone at the company can work on. It gets numbers, does some math, makes an API call, and waits for the next fact to show up. It’s our kernel space, bound by hard rules. &lt;/p&gt;
&lt;p&gt;But then there is the other half of the whole billing ecosystem: the control plane. That’s our userland. It’s a place where humans have to really think and agents can introduce gnarly bugs. If something breaks, folks get mad. Users are doing all sorts of normal user things like changing credit cards, cancelling subscriptions, and upgrading their plans. Douglas Adams described it well: &lt;/p&gt;
&lt;p&gt;&lt;em&gt;“Anything that, in happening, causes itself to happen again, happens again. It doesn&#39;t necessarily do it in chronological order, though.”&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;The billing side is dictated by reconciliation workers and provider API calls. What’s the equivalent in the control plane? Two models: Account and Account Plan. An Account is a billable entity owned by a user or a team. The Account Plan represents the current billing state of that Account.&lt;/p&gt;
&lt;p&gt;Account Plans are the bridge between the two worlds. They reference our internal pricing catalog, which tells the billing side how to calculate the billable quantity and send it to the right price or meter in Stripe.&lt;/p&gt;
&lt;p&gt;Our world looks like this:&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/1793219677-image.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;We’ve (mostly) avoided creating a billing hellscape no one wants to touch. Our recent pricing change put that architecture to the test.&lt;/p&gt;
&lt;p&gt;It took a few rounds of feedback, but this architecture let me focus on billing and pricing decisions. The agents handled implementation. I gave them four tasks:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Add a new plan to the catalog and configure it in Stripe.&lt;/li&gt;
&lt;li&gt;Track usage for pools and reconcile the billing.&lt;/li&gt;
&lt;li&gt;Let users upgrade to the new plans.&lt;/li&gt;
&lt;li&gt;Show the new pricing on exe.dev/pricing.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I won’t lie. I had reservations about this approach. At launch, I was glued to our internal tools to make sure nothing broke. Sure enough, shortly after launch, the first major issue showed up: a pricing problem.&lt;/p&gt;
&lt;p&gt;Alongside pools, we’d introduced a new Work plan that charged for compute instead of seats. It had a $150 monthly minimum that included 4 vCPUs and 8 GB of memory. The billing code worked, but new team signups ground to a halt.&lt;/p&gt;
&lt;p&gt;After a few days without a new team signing up, we suspected the $150 minimum was too high. We had agents query our analytics database to investigate and decided to test a lower price. The first rollout had gone smoothly on the technical side. Could we use the same approach to run a pricing experiment?&lt;/p&gt;
&lt;p&gt;So we landed on two decisions: cut the price in half and offer a 50 percent off coupon for the first three months. That brought the Work plan’s monthly minimum to $37.50 for the first three months. It would also let teams try exe without a major upfront commitment. The change was done in one afternoon by our agents. After a day or so, Work signups returned to normal levels.&lt;/p&gt;
&lt;p&gt;A new major feature backed by two pricing changes that didn&#39;t cause catastrophic failures? Oh, and folks who want to keep their current plan can still do so without issue? I think it is safe to say that agents can handle billing just fine. You just have to design the system with agents in mind.&lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Introducing execonnect: Access Private HTTP Services from exe.dev</title>
    <link href="https://blog.exe.dev/execonnect" />
    <id>https://blog.exe.dev/execonnect</id>
    <updated>2026-10-29T18:41:24Z</updated>
    <summary>Connect your exe.dev VMs to private HTTP services with an open source tool that runs inside your network.</summary>
    <content type="html">&lt;p&gt;&lt;strong&gt;execonnect&lt;/strong&gt; is a way to let your exe.dev VMs connect to HTTP services, even if those services aren’t on the public internet. You run &lt;a href=&#34;https://github.com/boldsoftware/exe.dev/tree/main/execonnect&#34;&gt;execonnect&lt;/a&gt; on the machine hosting the service (or on any machine that &lt;em&gt;can&lt;/em&gt; access the service), and this establishes a link between your service and exe.dev. From that point on, you can &lt;a href=&#34;https://exe.dev/docs/integrations-external-connections&#34;&gt;configure integrations&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;For example, at exe.dev, we run a Victoria Metrics service inside of our network. I’m running &lt;code&gt;execonnect&lt;/code&gt; inside the VM, and there’s a “victoria” integration in exe, and I can access our metrics. I configured it as a team integration, so it works for all of my co-workers as well.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/execonnect-diagram.png&#34; alt=&#34;Diagram: inside the exe.dev production network, a monitoring VM runs Victoria Metrics and exe connect. exe connect dials out to the exe.dev exe connect switchboard. On my development VM, a Shelley session asked to “use the victoria integration to build a distribution of our disk usage” runs curl, sending GET /query to victoria.int.exe.xyz; the exe.dev integrations proxy forwards it through the switchboard to exe connect, which sends GET /query to Victoria Metrics. Caption: exe connect dials out to the switchboard, so requests from my VM reach the monitoring server (which isn’t on the public internet).&#34; width=&#34;720&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;p&gt;How does it work? Execonnect is a Go program with a userspace wireguard. On the exe.dev side, our anycast proxy network works as the other end of that wireguard tunnel. Execonnect—the part which you may run in your own infrastructure—is &lt;a href=&#34;https://blog.exe.dev/devtools-must-be-open-source&#34;&gt;open source&lt;/a&gt;, of course, so you can see what it’s doing.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger and Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Run Claude and GPT on exe.dev Without API Keys</title>
    <link href="https://blog.exe.dev/llms-without-api-keys" />
    <id>https://blog.exe.dev/llms-without-api-keys</id>
    <updated>2026-10-28T21:20:00Z</updated>
    <summary>Connect your exe.dev VMs to Anthropic and OpenAI with Workload Identity Federation.</summary>
    <content type="html">&lt;p&gt;&lt;a href=&#34;https://exe.dev/&#34;&gt;exe.dev&lt;/a&gt; integrations let you store secrets with exe.dev’s control plane so your VMs (and the agents on those VMs) can access services without seeing the secrets themselves. The next step is to avoid having the secret to begin with. When &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; and the other service both support &lt;a href=&#34;https://blog.exe.dev/oauth-for-agents&#34;&gt;Workload Identity Federation&lt;/a&gt; (WIF), you can do just that.&lt;/p&gt;
&lt;p&gt;If you’ve been using API keys for &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt;’s LLM gateway, there’s now another way. Both Anthropic and OpenAI support Workload Identity Federation. Two fewer keys to lose!&lt;/p&gt;
&lt;p&gt;Pro tip: agents are excellent at configuring WIF on your behalf.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/llm-wif-add-integration.png&#34; alt=&#34;The Add Identity Federation Integration dialog in exe.dev, showing the issuer and subject to configure on the Anthropic side&#34; width=&#34;600&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/llm-wif-workload-identity.png&#34; alt=&#34;An Anthropic LLM integration set to use Workload identity&#34; width=&#34;720&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;</content>
    <author>
      <name>Philip Zeyliger and Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Automatic Compaction: How Shelley Keeps Going and Going Without Losing the Plot</title>
    <link href="https://blog.exe.dev/compaction" />
    <id>https://blog.exe.dev/compaction</id>
    <updated>2026-10-27T16:00:00Z</updated>
    <summary>At about 200k tokens, the harness nudges the model to use a compaction-in-place tool to trim tool outputs and squish messages together.</summary>
    <content type="html">&lt;p&gt;When it comes to LLMs, context rules everything around us. An agent loop is inherently quadratic: messages accumulate and every iteration you send the full stack of messages to the model. That stack of messages is &lt;em&gt;the context&lt;/em&gt;, and it starts with a system prompt, descriptions of the tools, and your instructions. Messages upon messages get added. Tool responses (in other words, the agent reading your source code) usually end up being the majority of the context. This impacts cost (see &lt;a href=&#34;https://blog.exe.dev/expensively-quadratic&#34;&gt;Expensively Quadratic: the LLM Agent Cost Curve&lt;/a&gt;) and quality. You want to give the model just the &amp;quot;right amount&amp;quot; of context, but how?&lt;/p&gt;
&lt;div class=&#34;excalimux-anim&#34; data-src=&#34;/assets/compaction-context.svg&#34; role=&#34;img&#34; aria-label=&#34;Every LLM call resends the whole context&#34;&gt;&lt;noscript&gt;&lt;img src=&#34;/assets/compaction-context-final.png&#34; alt=&#34;Every LLM call resends the whole context&#34;&gt;&lt;/noscript&gt;&lt;/div&gt;
&lt;script src=&#34;/assets/excalimux-player.js&#34; defer=&#34;&#34;&gt;&lt;/script&gt;
&lt;p&gt;&lt;em&gt;Compaction&lt;/em&gt; is the process of taking your current (long) conversation and rewriting or removing stuff to make it a shorter conversation.&lt;/p&gt;
&lt;p&gt;Shelley&#39;s approach to compaction is to insert a &amp;quot;nudge&amp;quot; message from the harness at about 200k tokens and to give the model a compaction tool that lets it (a) truncate specific tool outputs and (b) &amp;quot;squish&amp;quot; together sections of history into smaller, rewritten segments (which will then have pointers to the originals). 200k seems like the sweet spot for current frontier models, but we&#39;ve left the exact number configurable.&lt;/p&gt;
&lt;p&gt;The compaction tool requires a few rounds. First, the model gets an &amp;quot;index&amp;quot; so that it can identify the messages by a sequential id. Then, the model suggests messages to collapse or trim. Shelley has a &amp;quot;linter&amp;quot; that verifies that the compaction isn&#39;t too big or too little. The model tries again, and usually the second time is just right. After compaction, the conversation continues as it always did, except the squished chunks are shorter, the verbose tool outputs are trimmed, and evidence of the compaction is no longer visible to the LLM.&lt;/p&gt;
&lt;p&gt;From a data model perspective, a Shelley conversation has some mutable state (slug name, model choice, current draft) and an append-only log of messages. Compaction is materialized as special &amp;quot;compaction&amp;quot; messages, and the harness, when concatenating all the messages together to send to the LLM, replaces the relevant chunks with their rewrites and trimmed results. If the model ever wants to read something that got compacted away, the data is in SQLite, and Shelley has a skill to hint at the right query. (One of Shelley&#39;s principles is the ability to be introspective. I tuned the linter heuristics by having Shelley introspect and backtest its own past conversations.)&lt;/p&gt;
&lt;div class=&#34;excalimux-anim&#34; data-src=&#34;/assets/compaction-inplace.svg&#34; role=&#34;img&#34; aria-label=&#34;Shelley&#39;s in-place compaction&#34;&gt;&lt;noscript&gt;&lt;img src=&#34;/assets/compaction-inplace-final.png&#34; alt=&#34;Shelley&#39;s in-place compaction&#34;&gt;&lt;/noscript&gt;&lt;/div&gt;
&lt;p&gt;This is Shelley&#39;s third(!) implementation of compaction. The previous two implementations started a new &amp;quot;generation&amp;quot; of a conversation inside the same conversation, with a brand-new context and a summary (first implementation), and preserving the most recent messages (second implementation). This third implementation keeps it going as one conversation, but the history is somewhat rewritten. I&#39;d love to believe this is our last implementation, but model capabilities have been changing quickly, and I expect there will be more iteration.&lt;/p&gt;
&lt;p&gt;From the cost perspective, this is the cost graph for a recent long Opus 5.5 conversation. It adds up to about $25 and has gone through 4 compactions, with the context length capping out at about 200k. The little arrows where the price spiked are $1 cache misses, probably when I stepped away from the computer. (You can get this graph in your Shelley session by clicking on the context length counter.)&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/compaction-cost-graph.png&#34; alt=&#34;Shelley context and cost graph&#34; width=&#34;620&#34;&gt;
&lt;figcaption&gt;Context length and cumulative cost for a long Opus 5.5 conversation, across 4 compactions.&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;p&gt;We&#39;ve been rocking this implementation for a few weeks, and we think it works quite well. We&#39;ve enabled &amp;quot;auto compaction&amp;quot; by default. I used to click on &amp;quot;Compact and Send&amp;quot; every once in a while and look at the context length. Now, I just talk, and talk, and talk, and it&#39;s all good. I&#39;ve also started letting my agentic conversations meander a bit more, do follow-ups and so on.&lt;/p&gt;
&lt;p&gt;Tune in next week to hear about switching to asynchronous tool and subagent calls. Or maybe we&#39;ll talk more about multiple input modalities!&lt;/p&gt;
&lt;p&gt;If you&#39;re interested in more of our writing about coding agents:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;The Unreasonable Effectiveness of an LLM Agent Loop with Tool Use&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://blog.exe.dev/expensively-quadratic&#34;&gt;Expensively Quadratic: the LLM Agent Cost Curve&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://blog.exe.dev/topology&#34;&gt;The Topology of an LLM Agent Loop With Tool Use&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;P.S.: Here&#39;s a behind-the-scenes look at yak-shaving involved in building the animation above. I built it using Shelley, after having earlier built a bespoke program using &lt;a href=&#34;https://github.com/excalidraw&#34;&gt;Excalidraw&lt;/a&gt;, and after adding animations to said bespoke drawing program.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/compaction-animation-screenshot.png&#34; alt=&#34;The compaction animation in the drawing app&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;Building out the animations for this post in Shelley&lt;/figcaption&gt;
&lt;/figure&gt;</content>
    <author>
      <name>Philip Zeyliger and Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Hunting Bugs? Look at Commits</title>
    <link href="https://blog.exe.dev/commits-not-files" />
    <id>https://blog.exe.dev/commits-not-files</id>
    <updated>2026-10-23T20:00:00Z</updated>
    <summary>Point your agents at changes, then check whether the bugs still exist.</summary>
    <content type="html">&lt;p&gt;If you’re looking for bugs, you’ll get better results if you focus the agents’ attention.&lt;/p&gt;
&lt;p&gt;The usual loop is roughly:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;for f in files:
  &amp;#34;please look for important bugs, using $f as a starting point&amp;#34;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;But I&#39;ve found this to be more effective:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;for c in commits:
  &amp;#34;please analyze $c for important bugs; validate that they still exist at HEAD&amp;#34;
&lt;/code&gt;&lt;/pre&gt;</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Give Your Agents Less Internet</title>
    <link href="https://blog.exe.dev/internet-disconnect" />
    <id>https://blog.exe.dev/internet-disconnect</id>
    <updated>2026-10-22T17:37:00Z</updated>
    <summary>Without the internet, agents are useless. With the internet, they&#39;re dangerous. Introducing internet disconnect.</summary>
    <content type="html">&lt;p&gt;&lt;img src=&#34;/assets/internet-disconnect-billboard.png&#34; alt=&#34;The old Yahoo 101 billboard, but modified. It says &amp;quot;exe.dev, A nice place for your agents to stay off the Internet&amp;quot;, with &amp;quot;on&amp;quot; crossed out and replaced by &amp;quot;off&amp;quot;. A marquee sign below it reads &amp;quot;egress your-vm integrations&amp;quot;.&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Without the Internet, agents are useless. With the Internet, they&#39;re dangerous.&lt;/p&gt;
&lt;p&gt;One approach is to allow Internet access, but through carefully controlled sippy straws. Let through only requests to destinations that you trust and deny all of the rest.&lt;/p&gt;
&lt;p&gt;exe now makes this easy.&lt;/p&gt;
&lt;p&gt;TL;DR: Run &lt;code&gt;ssh exe.dev egress YOUR-VM integrations&lt;/code&gt;, or click the Network Access button on a VM&#39;s detail page. This will limit YOUR-VM&#39;s outbound internet access to any specific &lt;a href=&#34;https://exe.dev/docs/integrations&#34;&gt;integrations&lt;/a&gt; you have attached to that VM.&lt;/p&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;Exe integrations provide VMs access to other services, injecting credentials at the network edge so that secrets stay off the VM.&lt;/p&gt;
&lt;/aside&gt;
&lt;div class=&#34;img-row&#34;&gt;
&lt;img src=&#34;/assets/internet-disconnect-diagram.svg&#34; alt=&#34;Diagram: an exe VM&#39;s direct connections to a random website and to a trusted service are both blocked. The VM reaches the trusted service only through an exe integration.&#34;&gt;
&lt;img src=&#34;/assets/internet-disconnect-network-access.png&#34; alt=&#34;The Network access dialog for a VM, with two options: All destinations (unrestricted internet access) and Integrations only (allow attached integrations; block other outbound connections). Below them is the equivalent command, egress exfoliate all.&#34;&gt;
&lt;/div&gt;
&lt;h1&gt;Controlled Ingress, Controlled Egress&lt;/h1&gt;
&lt;p&gt;Exe manages both ingress and egress. Incoming connections are private by default; you choose who can access your VM.&lt;/p&gt;
&lt;p&gt;Outgoing connections are open by default, with integrations providing credentials for connected services. Now you can restrict outbound traffic to just those integrations, giving agents access to the services they need while blocking the rest of the internet.&lt;/p&gt;
&lt;h1&gt;How It Works&lt;/h1&gt;
&lt;p&gt;Egress filtering happens at a network packet level. Anything higher level than that is subject to an end run by agents: they have memorized DNS and they can find proxies to convert traffic from one shape to another. We run our own DNS servers to prevent DNS request smuggling. And when you switch egress to integrations-only, we disable server-side web tools on requests sent through our LLM gateway.&lt;/p&gt;
&lt;p&gt;People used to say things like &amp;quot;I&#39;m sure it&#39;s not secure against a nation-state attacker.&amp;quot; Frontier models are the new nation-states. But unlike nation-states, we can pen test ourselves using actual frontier models.&lt;/p&gt;
&lt;p&gt;The agents found a bunch of escapes, all through clever use of server-side tools from Anthropic and OpenAI. There were a surprising number of them. Models are clever and persistent. And—when multiple are running on a single VM concurrently—happy to claim credit for the discoveries of others. (Here’s to you, Grok.)&lt;/p&gt;
&lt;p&gt;As a result, we closed that entire pathway for requests using our LLM gateway. The rest of our system survived the trial by fire. We believe that we have closed all escape routes straightforwardly discoverable by current models. We will continue to probe in-house as new models are released and harden as needed.&lt;/p&gt;
&lt;h1&gt;Threat Model&lt;/h1&gt;
&lt;p&gt;Turning off general-purpose Internet access does make your VM more secure, but this is intended to protect against accidents, not an &lt;a href=&#34;https://en.wikipedia.org/wiki/Advanced_persistent_threat&#34;&gt;APT&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Also, it remains incumbent on you to think carefully about what an agent could do via the integrations you have attached. Are they usable as proxies for other purposes? Every read request from your agent is a write to someone else’s logs; are those writes acceptable? Put another way, your trust envelope now includes those external services.&lt;/p&gt;
&lt;p&gt;The traditional startup advice is to offer painkillers, not vitamins. Consider this to be Xanax; running agents should not fill you with anxiety that one mistake on their part will have disastrous consequences.&lt;/p&gt;
&lt;h1&gt;Advanced Mode&lt;/h1&gt;
&lt;p&gt;Our integrations give you high level access controls: connect to this Postgres server, connect to GitHub, connect to this website. If you want more control, consider setting up a proxy VM for yourself. Then set up a peer integration that allows your controlled VM to talk to your proxy VM. The proxy VM can then run arbitrary software to inspect requests and filter, augment, or forward them.&lt;/p&gt;
&lt;p&gt;There are no problems that cannot be solved with another layer of indirection except needing an infinite number of layers of indirection.&lt;/p&gt;
&lt;h1&gt;Sample Transcript&lt;/h1&gt;
&lt;p&gt;Create a new VM:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh exe.dev new --name=no-net
Creating no-net using image boldsoftware/exeuntu...

Coding agent
https://no-net.shelley.exe.xyz

App (HTTPS proxy → :8000)
https://no-net.exe.xyz

SSH
ssh no-net.exe.xyz
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;It has full internet access:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh no-net.exe.xyz curl -fsS https://exe.dev
Agent docs: https://exe.dev/llms.txt
Human docs: https://exe.dev/docs
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Limit its internet access to integrations only:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh exe.dev egress no-net integrations
Set egress policy for &amp;#34;no-net&amp;#34; to integrations
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Now the same request is rejected:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh no-net.exe.xyz curl -fsS https://exe.dev
curl: (6) Could not resolve host: exe.dev
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Create an integration that provides access:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh exe.dev integrations add http-proxy --name inception --target https://exe.dev --no-auth
Added integration inception

To use this integration, attach it to a VM first:
  integrations attach inception vm:&amp;lt;vm-name&amp;gt;

Usage from a VM:
  curl https://inception.int.exe.xyz/
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Attach it to our VM:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh exe.dev integrations attach inception vm:no-net
Attached inception to vm:no-net
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Access works via the integration:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh no-net.exe.xyz curl -fsS https://inception.int.exe.xyz/
Agent docs: https://exe.dev/llms.txt
Human docs: https://exe.dev/docs
&lt;/code&gt;&lt;/pre&gt;</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>The Topology of an LLM Agent Loop With Tool Use</title>
    <link href="https://blog.exe.dev/topology" />
    <id>https://blog.exe.dev/topology</id>
    <updated>2026-10-20T15:00:00Z</updated>
    <summary>An agent is a model, a loop, and a set of tools. Where each of those runs determines what the agent costs, what it can do, and how safe it is.</summary>
    <content type="html">&lt;p&gt;When I look at a new agent, I break it down by focusing on its topology. An agent is three things:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;A model. Your model choice defines the agent’s “smarts,” i.e., which tasks it can accomplish.&lt;/li&gt;
&lt;li&gt;The agentic loop (see: &lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;The Unreasonable Effectiveness of an LLM Agent Loop with Tool&lt;/a&gt;).  Loop choice determines UX.&lt;/li&gt;
&lt;li&gt;The set of tools. This defines the capabilities and power (and blast radius) an agent has.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;(2) and (3) together are often called “the harness.”&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/topology-diagram.svg&#34; alt=&#34;Three circles: Model (local? open weight? 4 cursed API shapes, physical location? size? speed? cost), Agent Loop (local or remote? where is message history? permissions? UI, subagents?), and Tools (bash? if so, where? MCP? Code Mode? asynchronous?). Agent Loop and Tools together are bracketed as the Harness.&#34; /&gt;&lt;/p&gt;
&lt;p&gt;All of this is code, and code has to run somewhere. Where these run—&lt;strong&gt;the topology of these agents&lt;/strong&gt;—has implications on cost, capability, effectiveness, and security for companies building AI products and people using AI tools.&lt;/p&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;&lt;strong&gt;Example 1: Claude Code&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Claude Code on your laptop uses Anthropic’s hosted model, runs the agentic loop on your laptop, and runs the tools also on your laptop.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-claude-code.svg&#34; alt=&#34;Three circles. Model: Cloud (Anthropic). Loop: Your laptop. Tools: Your laptop.&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;/aside&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;&lt;strong&gt;Example 2: ChatGPT&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;ChatGPT uses OpenAI’s hosted model, runs the agentic loop on their backend server, and runs tools also on their backend servers.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-chatgpt.svg&#34; alt=&#34;Three circles. Model: Cloud (OpenAI). Loop: Cloud (OpenAI). Tools: Cloud (OpenAI).&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;/aside&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;&lt;strong&gt;Example 3: Siri on your Mac&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Siri on your Mac uses a mix of models: smaller ones run on your Mac, and bigger ones run in Apple’s Private Cloud Compute. The agentic loop runs on your Mac, and so do the tools, like the one that reads your Messages.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-siri-mac.png&#34; alt=&#34;Siri on a Mac. Asked “How many iMessage messages did I receive today?”, it answers “You have three new messages in Messages.”&#34; width=&#34;370&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-siri.svg&#34; alt=&#34;Three circles. Model: split by a dashed line into Your Mac and Cloud (Apple). Loop: Your Mac. Tools: Your Mac.&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;/aside&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;&lt;strong&gt;Example 4: Amp Orbs&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://ampcode.com/notes/orbs-explained&#34;&gt;Amp Orbs&lt;/a&gt; use models from Anthropic, OpenAI, and others, run the agentic loop in Amp’s backend, and run the tools in your Orb, a VM that Amp creates for each thread with your code on it.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-amp.svg&#34; alt=&#34;Three circles. Model: Cloud (Anthropic, OpenAI, etc.). Loop: Cloud (Amp). Tools: Your Orb VM.&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;/aside&gt;
&lt;aside class=&#34;callout callout-info&#34;&gt;
&lt;p&gt;&lt;strong&gt;Example 5: Shelley on exe.dev&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;If you’re using our Shelley coding agent on an exe.dev VM, the model is hosted, and the agent and the tools run on the VM.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/topology-shelley.svg&#34; alt=&#34;Three circles. Model: Cloud (Anthropic, OpenAI, etc.). Loop: Your exe.dev VM. Tools: Your exe.dev VM.&#34; width=&#34;560&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;/aside&gt;
&lt;p&gt;In all of these cases, remote MCP servers can expose tools running elsewhere.&lt;/p&gt;
&lt;h2&gt;Where Is the Model?&lt;/h2&gt;
&lt;p&gt;Your choices here are GPUs hosted by someone else or your own GPUs.&lt;/p&gt;
&lt;p&gt;As the &lt;a href=&#34;https://www.science.org/content/article/how-ai-math-breakthrough-ignited-controversy&#34;&gt;controversy around the Navier-Stokes equation&lt;/a&gt; reminds us, the only way to be confident nobody is training on your data is to not send your data to them. If you’re working on common problems, it probably doesn’t matter. But I suspect a &lt;em&gt;hapax legomenon&lt;/em&gt; could end up in the training data somewhere.&lt;/p&gt;
&lt;p&gt;If I want to, say, use some LLMs to OCR and classify some scanned bills on my computer, I’m reaching for local models, because speed doesn’t matter (it can run overnight), and privacy is guaranteed. (Shout out to the Apple Vision Framework, by the way. And &lt;a href=&#34;https://apps.philz.dev/scanshelf&#34;&gt;ScanShelf&lt;/a&gt; is an example where I do this!)&lt;/p&gt;
&lt;p&gt;Ken Thompson’s 1984 Turing Award lecture, &lt;a href=&#34;https://www.cs.cmu.edu/~rdriley/487/papers/Thompson_1984_ReflectionsonTrustingTrust.pdf&#34;&gt;Reflections on Trusting Trust&lt;/a&gt;, hits different now. That paper poses how a Trojan Horse could be hidden in a compiler, invisible in the compiler’s source code, as it’s propagated by the compiler. The LLM (a compiler? maybe? &lt;a href=&#34;https://blog.exe.dev/claude-is-not-a-compiler&#34;&gt;no&lt;/a&gt;?) could have some tampered weights that lead the agent to do something naughty; &lt;a href=&#34;https://projectdiscovery.io/research/how-abliterated-models-can-get-you-pwned?utm_source=chatgpt.com&#34;&gt;it’s been tried&lt;/a&gt;. We must choose which vendors to trust.&lt;/p&gt;
&lt;p&gt;LLMs are wreaking havoc on traditional SaaS cost structures as well. If you have, for example, a diagram-drawing SaaS, and you want to let your users use agents to edit the diagrams: who’s paying for the tokens? Before agents, your costs were a few database rows per customer; now that customer can rack up a $100 bill with a few sentences. At exe.dev, our users can bring their own ChatGPT subscriptions to build applications with OpenAI models. This is a win-win. I expect we’ll see more “bring your own model” options.&lt;/p&gt;
&lt;div class=&#34;video-figure&#34;&gt;&lt;figure&gt;&lt;video controls=&#34;&#34; playsinline=&#34;&#34; preload=&#34;metadata&#34; width=&#34;2014&#34; height=&#34;1080&#34; poster=&#34;/assets/topology-drawing-agent-poster.jpg&#34;&gt;&lt;source src=&#34;/assets/topology-drawing-agent.mp4&#34; type=&#34;video/mp4&#34;&gt;&lt;/video&gt;&lt;figcaption&gt;This is my bespoke drawing editor, with a built-in agent. You’re going to see “agent drawers” in every product.&lt;/figcaption&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;h2&gt;Where is the loop?&lt;/h2&gt;
&lt;p&gt;If you’re using, say, ChatGPT, the loop is running in OpenAI’s servers. If you’re running a coding agent, the loop is running on your laptop. The loop could run in a web browser (e.g., as I did in &lt;a href=&#34;https://itsy-bitsy.philz.dev/&#34;&gt;ItsyBitsy&lt;/a&gt;, and as many others have as well).&lt;/p&gt;
&lt;p&gt;I have found over and over again that I find other people’s loops limiting. For example, I much prefer pointing my preferred agent at my source code and my observability tooling rather than using the observability vendor’s agent loop.&lt;/p&gt;
&lt;p&gt;The loop has to maintain the message history (since an LLM agent is operating on the entire history), and that has to be stored somewhere. Storing it in SQLite for Shelley remains a decision I’m very happy with. &lt;a href=&#34;https://earendil.com/posts/pi-durable/&#34;&gt;Pi Durable&lt;/a&gt; also offers SQLite.&lt;/p&gt;
&lt;img src=&#34;/assets/topology-no-jsonl.svg&#34; alt=&#34;JSONL, crossed out&#34; width=&#34;160px&#34;&gt;
&lt;p&gt;The loop also provides the UI for the agent. Can it display images? Are there customizations to give feedback on video? Is it limited to plain text? Can it handle attachments? Can a conversation be shared? All of these are choices the loop must make.&lt;/p&gt;
&lt;h2&gt;Where are the Tools?&lt;/h2&gt;
&lt;p&gt;Agents aren’t agents without tools. The jump from one “completion” from an LLM to an agentic loop is transformational. If an agent can empirically test the thing it’s writing, the results are better.&lt;/p&gt;
&lt;p&gt;The problem with executing code is that, well, you have to do it somewhere, and you have to assume that the code being executed is unpleasant and will steal all the cookies from your pantry and set off the fire alarms at night unnecessarily (or worse).&lt;/p&gt;
&lt;p&gt;The code execution isn’t lightweight: it’s not all editing files; compilation, video processing, running tests… the workload can be heavy.&lt;/p&gt;
&lt;p&gt;Virtual Machines are the gold standard for executing code safely. Even with VMs, there are tons of variables: can it talk to the network? Does it have credentials to talk to other services? Is there enough memory?&lt;/p&gt;
&lt;p&gt;Running coding agents locally works too, but the blast radius for the “&lt;a href=&#34;https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/&#34;&gt;Lethal Trifecta&lt;/a&gt;” is bigger. Exposure to untrusted content could lead the agent to leak secrets, for example.&lt;/p&gt;
&lt;p&gt;You can build many useful agents without a full machine. Pyodide, a Python running in WASM, is sandboxable without a full machine. Likewise, there are several WASM JS implementations. You can always run the agent loop on the browser, too, which runs sandboxed code day in and out. (See &lt;a href=&#34;https://blog.philz.dev/blog/sandboxes/&#34;&gt;https://blog.philz.dev/blog/sandboxes/&lt;/a&gt; for a short list of some of these approaches.) You can also give an agent the ability to run SQL on a readonly database connection, and that’s pretty safe!&lt;/p&gt;
&lt;p&gt;Note that the tools don’t have to be in the same address space as the loop; they don’t even need to be in the same neighborhood. When you’re using a “Connector” in ChatGPT (roughly their word for MCP), you’re giving the agent loop (which is hosted by OpenAI) access to resources somewhere else. Concretely, if you use the &lt;a href=&#34;https://exe.dev/mcp&#34;&gt;exe.dev MCP&lt;/a&gt;, your ChatGPT can operate on your exe VMs. When you’re talking about MCP, map out where the OAuth tokens are held.&lt;/p&gt;
&lt;p&gt;To make their products useful, Muse, GrokBot, OpenAI Dots, and so on are all providing VMs.&lt;/p&gt;
&lt;h2&gt;Mapping Agents&lt;/h2&gt;
&lt;p&gt;There are tradeoffs everywhere you look. Framed as topology, you can break down any agentic product. Once you know what’s running where, you can reason about what a product can and cannot do.&lt;/p&gt;
&lt;p&gt;In my work at exe.dev, I use five independent agentic loop implementations nearly every day. (Our coding agent, Shelley; our alert agent, Sisyphus; our deployment supervisor, &lt;a href=&#34;https://blog.exe.dev/athena-deploys-exe&#34;&gt;Athena&lt;/a&gt;; an ops agent, Puck; our repo news Slack agent.) Shelley is a general purpose coding agent, but the other four are bespoke software. More and more software will ship with agentic loops built-in.&lt;/p&gt;
&lt;p&gt;I also constantly interact with other systems, and use agents to glue them together. The companies that get it make their product legible to coding agents. I can just smell Clayton Christensen&#39;s Innovator&#39;s Dilemma as I switch from better, more polished, established products to ones that let me point an agent at them. Of the nine points in &lt;a href=&#34;https://blog.exe.dev/revisiting-joel&#34;&gt;Revisiting Joel’s Test&lt;/a&gt;, this is the most important one.&lt;/p&gt;
&lt;p&gt;There is no “one loop to rule them all.” Good UX (and a good set of tools) for a general-purpose chatbot is not the same as good UX for a coding agent.&lt;/p&gt;
&lt;p&gt;I leave you with the most useful code of the year. When you insert agents into your products, think of the topology of those agents.&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code class=&#34;language-python&#34;&gt;def loop(llm):
    msgs, msg = [], user_input()
    while True:
        msgs &#43;= [msg]
        output, tool_calls = llm(msgs)
        print(&amp;#34;Agent: &amp;#34;, output)
        if tool_calls:
            msg = [ handle_tool_call(tc) for tc in tool_calls ]
        else:
            msg = user_input()
&lt;/code&gt;&lt;/pre&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Join Us: exe&#39;s First Meetup in San Francisco</title>
    <link href="https://blog.exe.dev/exe-first-meetup-san-francisco" />
    <id>https://blog.exe.dev/exe-first-meetup-san-francisco</id>
    <updated>2026-10-19T18:30:00Z</updated>
    <summary>We&#39;re hosting our first technical meetup at the Sentry office in San Francisco on October 26.</summary>
    <content type="html">&lt;p&gt;Maybe it&#39;s the years we spent on Zoom? San Francisco seems hungry for in-person events, and we&#39;re no exception.&lt;/p&gt;
&lt;p&gt;We&#39;re hosting our first technical meetup for developers on Monday, October 26, from 6 to 9pm at the Sentry office in San Francisco. The question of the evening: Are we running too many agents?&lt;/p&gt;
&lt;p&gt;The topic comes from Josh&#39;s recent post, &lt;a href=&#34;https://blog.exe.dev/etoomanythings&#34;&gt;ETOOMANYTHINGS? Run Fewer Agents&lt;/a&gt;, which sparked some interesting discussion online. We figured it would be fun to continue the conversation and debate in person.&lt;/p&gt;
&lt;p&gt;We&#39;ve invited a few exe friends to give some talks on the theme:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Josh Bleecher Snyder is the cofounder of exe and the person who got this whole conversation started. He&#39;ll be talking about whether we&#39;re building software factories incorrectly.&lt;/li&gt;
&lt;li&gt;Beyang Liu is working on amplifying human agency at Amp and previously cofounded Sourcegraph.&lt;/li&gt;
&lt;li&gt;Josh Wills is an engineer at DatologyAI, with a long history of building developer tools and infrastructure.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;We&#39;ll follow the talks with an open Q&amp;amp;A. Bring your questions and opinions to participate in the conversation.&lt;/p&gt;
&lt;p&gt;There will be pizza and drinks, too. A big thank you to Sentry for sponsoring.&lt;/p&gt;
&lt;p&gt;We&#39;d love to have you there. Sign up here: &lt;a href=&#34;https://luma.com/0qr6bxcw&#34;&gt;https://luma.com/0qr6bxcw&lt;/a&gt;&lt;/p&gt;
</content>
    <author>
      <name>Jana Iris</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Shake to Tell Shelley</title>
    <link href="https://blog.exe.dev/shake-to-tell-shelley" />
    <id>https://blog.exe.dev/shake-to-tell-shelley</id>
    <updated>2026-10-16T16:30:00Z</updated>
    <summary>Iteration (culture) is eating planning (strategy) for lunch.</summary>
    <content type="html">&lt;p&gt;When I want to improve one of my iOS apps, I shake my phone, type in a prompt, and off it goes to &lt;a href=&#34;https://shelley.dev/&#34;&gt;Shelley&lt;/a&gt;, together with a screenshot!&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/shake-to-tell-shelley.webp&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Iteration (culture) is eating planning (strategy) for lunch.&lt;/p&gt;
&lt;p&gt;I&#39;m finding that grinding down the friction, even as minimal as getting myself to the agent input, enables iteration.&lt;/p&gt;
&lt;p&gt;Ideally, you could just customize the app from within itself, like &lt;a href=&#34;https://apps.philz.dev/pliable&#34;&gt;Pliable&lt;/a&gt; does, but that would be against the app store rules.&lt;/p&gt;
&lt;iframe src=&#34;https://embed.bsky.app/embed/did:plc:cqw3c3jwrh3biffjthby5yao/app.bsky.feed.post/3mx5dn4r2f22m?colorMode=light&#34; title=&#34;Philip Z’s Bluesky post about Pliable&#34; width=&#34;100%&#34; height=&#34;650&#34; frameborder=&#34;0&#34; loading=&#34;lazy&#34; allowfullscreen=&#34;&#34;&gt;&lt;/iframe&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>A Healthier Way to Snack on UI Work</title>
    <link href="https://blog.exe.dev/implementation-fidelity" />
    <id>https://blog.exe.dev/implementation-fidelity</id>
    <updated>2026-10-14T20:40:00Z</updated>
    <summary>I built Radiant, an agent-driven design tool that creates UI mockups grounded in our existing code.</summary>
    <content type="html">&lt;p&gt;Snacking—focusing on small, shippable tasks that make the product better but don’t necessarily help it grow—is addictive. Sometimes your main project is a slog. Why not take a break and fix something? You get that sense of accomplishment and suddenly your main project feels less daunting (the power of dopamine!).&lt;/p&gt;
&lt;p&gt;My guilty snack is UI work. I started out my career as a mostly front-end engineer. I would obsess over pixel-perfect designs and building a strong FE style guide (this was before they were even called style guides). Chris Eppstein’s &lt;a href=&#34;https://chriseppstein.github.io/&#34;&gt;Compass&lt;/a&gt; was my bread and butter. I’ve since moved on to other roles and I am not doing much front-end work these days. So how do I satisfy my cravings?&lt;/p&gt;
&lt;p&gt;I recently built a Figma-like tool called Radiant. Except, unlike Figma, Radiant is 100 percent agent-driven. It allows me to snack in a healthier way on UI work because it generates high-fidelity mockups based on prompts I provide. Also, instead of the traditional approach wherein someone gives the engineer a mockup that is either way out of scope or just technically infeasible, Radiant constrains itself to what our &lt;em&gt;current&lt;/em&gt; code is capable of doing. Agents are great at scanning code and doing a deep dive on all the layers. So why not use that to our advantage when mocking up UI?&lt;/p&gt;
&lt;p&gt;To prove this idea, I decided to tackle a rough part of our UI: the current user dropdown. I had Radiant look at the current implementation and, based on the issues I called out, redesign it in a mockup and present some options. (For context, the model I used was Claude Fable).&lt;/p&gt;
&lt;p&gt;Here’s what we got:&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/CleanShot-2026-08-01-at-21.48.27.55deaeb359d04d12aca829238cf8dd59.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/1787757509-CleanShot-2026-08-01-at-21.51.29.ae439dc4cfc7429aa161ac621f6dcbec.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;What impressed me was that Radiant also managed to pull our current styles &lt;em&gt;from our code&lt;/em&gt; to generate these mocks. This was exactly what I wanted because instead of hallucinating a UI, Radiant just took what we had and modified it and presented multiple options. Once I chose a design, the final chef’s kiss was having Radiant generate a prompt to hand off to another agent for the implementation. That agent was able to one shot implement it (I used Claude Fable for the implementation).&lt;/p&gt;
&lt;p&gt;Radiant is still new in my toolbox, but being able to do UI work by asking for mockups and then quickly iterating on them is my new favorite way to snack.&lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>An Agent Over Your Shoulder</title>
    <link href="https://blog.exe.dev/agent-over-your-shoulder" />
    <id>https://blog.exe.dev/agent-over-your-shoulder</id>
    <updated>2026-10-08T15:00:00Z</updated>
    <summary>Shoulder shares your terminal with an agent, so it can watch your logs alongside you (or play Tetris, badly).</summary>
    <content type="html">&lt;p&gt;The other day I was doing some ops work, live migrating some VMs from one physical host to another, as we sometimes need to do. This process is nearly transparent (except a pause) to our users, but I wanted an extra set of “attention heads” on it, so I built &lt;a href=&#34;https://github.com/boldsoftware/shoulder&#34;&gt;shoulder&lt;/a&gt; (as in “look over your shoulder.”)&lt;/p&gt;
&lt;p&gt;With shoulder, you start a terminal and run shoulder, which runs bash inside of it, but not before offering a bunch of ways to connect to it. If your agent is local, you can connect locally, but you can connect from anywhere with &lt;a href=&#34;https://github.com/tailscale/tailcat&#34;&gt;tailcat&lt;/a&gt;. The agent can see and control your terminal, which makes it good enough to read your logs and highlight something you may have missed.&lt;/p&gt;
&lt;p&gt;Or you can be silly and have Luna play Tetris poorly. That works too.&lt;/p&gt;
&lt;video controls=&#34;&#34; playsinline=&#34;&#34; preload=&#34;metadata&#34; poster=&#34;/assets/shoulder-tetris-poster.jpg&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
    &lt;source src=&#34;/assets/shoulder-tetris.mp4&#34; type=&#34;video/mp4&#34;&gt;    Your browser does not support the video tag.
  &lt;/video&gt;
&lt;p&gt;My first iteration here had a TUI with a split screen, with the agent on one half and the terminal in the other, much like a custom &lt;code&gt;tmux&lt;/code&gt; layout. I tried it and I hated it: my preferred agent is one thing (it happens to be Shelley in a web browser) and my preferred terminal is another (it happens to be Ghostty), and it’s much better to bridge the two!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Crossing the Hyper-Thread Boundary</title>
    <link href="https://blog.exe.dev/crossing-the-hyper-thread-boundary" />
    <id>https://blog.exe.dev/crossing-the-hyper-thread-boundary</id>
    <updated>2026-10-07T16:35:00Z</updated>
    <summary>Your VMs can share a CPU core. You get to decide who they share it with.</summary>
    <content type="html">&lt;p&gt;Modern processors have multiple CPU cores, and the physical CPU cores in turn have two logical CPU cores. The latter permit the physical core to run two independent programs simultaneously, an approach known as &lt;a href=&#34;https://en.wikipedia.org/wiki/Hyper-threading&#34;&gt;hyper-threading&lt;/a&gt;. Hyper-threading uses CPU resources more efficiently, but it exposes transient execution vulnerabilities, in which a program running on one hyper-thread is able to extract data from the program running on the other hyper-thread. An example of such an attack is &lt;a href=&#34;https://docs.kernel.org/6.2/admin-guide/hw-vuln/mds.html&#34;&gt;MDS&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; runs virtual machines on behalf of different users. We need to protect against the possibility of one user exploiting a vulnerability to extract data from another user running on a different hyper-thread of the same CPU core. Fortunately the Linux kernel supports &lt;a href=&#34;https://docs.kernel.org/admin-guide/hw-vuln/core-scheduling.html&#34;&gt;core scheduling cookies&lt;/a&gt; to control which processes are permitted to share a CPU core.&lt;/p&gt;
&lt;p&gt;It is straightforward to give each VM an independent cookie, meaning that two different VMs never run on the same CPU core. However, in practice this leads to measurably inefficient use of physical CPU cores. So we instead implemented a more efficient, but still secure, mechanism: the VMs of each team use an independent cookie. This means that two different VMs from a different team (or from a different user for users not on teams) never run on the same CPU core. To put it another way, we assume that different members of the same team trust each other.&lt;/p&gt;
&lt;p&gt;Of course, for various reasons, some teams do not have trust among all their VMs. An admin of those teams can run &lt;code&gt;ssh exe.dev team settings core-sharing off&lt;/code&gt; to prevent their VMs from sharing CPU cores. (Currently VMs that do not belong to a team never share cores with other VMs, even VMs from the same user; if that changes someday we will introduce a similar setting for individuals.)&lt;/p&gt;
</content>
    <author>
      <name>Ian Lance Taylor</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>The Hardest Working Header on the Internet</title>
    <link href="https://blog.exe.dev/the-hardest-working-header-on-the-internet" />
    <id>https://blog.exe.dev/the-hardest-working-header-on-the-internet</id>
    <updated>2026-10-05T20:55:00Z</updated>
    <summary>How your browser finds the right website when they all share an IP address.</summary>
    <content type="html">&lt;p&gt;When your browser reads this blog, it looks up &lt;code&gt;blog.exe.dev&lt;/code&gt; using DNS, and sends an HTTP request with a &lt;code&gt;Host: blog.exe.dev&lt;/code&gt; header to our servers. Our anycast network receives the request and uses &lt;code&gt;Host: blog.exe.dev&lt;/code&gt; to figure out which of all the exe VMs to proxy your request to. Load balancers, CDNs, web servers… the modern web works because of the humble &lt;code&gt;Host&lt;/code&gt; header. (&lt;a href=&#34;https://blog.exe.dev/ssh-host-header&#34;&gt;SSH does not have such a header&lt;/a&gt;, alas.)&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; lets you &lt;a href=&#34;https://exe.dev/docs/cnames&#34;&gt;bring your own custom domain&lt;/a&gt; to point to your VM. Thanks to Let’s Encrypt, we&#39;re able to provision the certificate on your behalf. And, now, we also let you provision a wildcard certificate, so you can have, for example, &lt;code&gt;*.example.com&lt;/code&gt; all point to the same VM, and you can route accordingly. &lt;code&gt;domain add vm-name *.example.com&lt;/code&gt; in our lobby is the place to get started, and it&#39;ll walk you through it.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;An earlier version of this blog post falsely accused Certificate Transparency of delaying how quickly custom domains started working. This is no longer a problem! (DNS time-to-live configuration remains an occasional stumbling block, though.)&lt;/em&gt;&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>ETOOMANYTHINGS? Run Fewer Agents</title>
    <link href="https://blog.exe.dev/etoomanythings" />
    <id>https://blog.exe.dev/etoomanythings</id>
    <updated>2026-10-01T13:00:00Z</updated>
    <summary>Spinning up more agents to hide latency wrecks your attention. Fix the human-agent loop instead.</summary>
    <content type="html">&lt;p&gt;At a conference last week, I sat through a bunch of &lt;a href=&#34;https://blog.exe.dev/bones-of-the-software-factory&#34;&gt;software factory demos&lt;/a&gt;, and they were all about task management. Kanban boards, Slack interfaces, email interfaces, dependency graphs, ticketing, graphical interfaces, you name it.&lt;br /&gt;
&lt;br /&gt;
Why is everyone building task management and calling it a software factory? Agents are slow to execute. And the obvious, easy fix to latency is to hide it by &lt;a href=&#34;https://sketch.dev/blog/seven-prompting-habits&#34;&gt;starting a new agent every time you get blocked&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;But concurrency is really rough on humans. It’s stressful. It trashes flow state and thrashes our mental page caches.&lt;/p&gt;
&lt;p&gt;Task management isn&#39;t a solution; it&#39;s a band-aid.&lt;/p&gt;
&lt;p&gt;This is a call to arms. Let’s make it possible to be equally productive with fewer agents.&lt;/p&gt;
&lt;h3&gt;Bitter Lesson to the Rescue?&lt;/h3&gt;
&lt;p&gt;As models improve, “good enough” models will get ever faster. This will naturally &lt;a href=&#34;https://vimeo.com/906418692&#34;&gt;reduce latency&lt;/a&gt;, and in turn concurrency. We’ll still have to do some old-fashioned engineering, like making tests run fast.&lt;/p&gt;
&lt;p&gt;But we don&#39;t have to wait! Here are some things we’ve experimented with at exe.&lt;/p&gt;
&lt;h3&gt;Use a Fast Model for Talking With Humans&lt;/h3&gt;
&lt;p&gt;Start tasks with a powerful model. But instead of reading a wall of text and writing an essay in response, put all the comms in the hands of a fast, competent model like Luna 6. Give Luna no coding tools, and make its context window intentionally short and focused on what the human conversation requires. Then, when you go to check in on a task, you can have real-time discussions with Luna. With a fast feedback cycle, &lt;a href=&#34;https://www.nngroup.com/articles/response-times-3-important-limits/&#34;&gt;attention doesn’t wander&lt;/a&gt;, and you can stay engaged for longer. Eventually, Luna exhausts its ready information, and the beefier model takes back over, with rich, substantial user feedback to work from.&lt;/p&gt;
&lt;p&gt;This works reasonably well. But we found that, shock of shocks, absorbing information via chat was rather constraining. It was frustrating to have communications be squeezed through a tiny pipe. Luna might be an exciting, bendy straw, but it’s still a straw.&lt;/p&gt;
&lt;h3&gt;Screen Recording&lt;/h3&gt;
&lt;p&gt;That led us to focus on the HCI aspects of the problem. Back when I coded by hand, I would stare intently at screens full of text, processing it slowly, navigating freely between files, thinking. But the UI that is presented by most coding harnesses is a single linearized text thread, typically interspersed with lots of irrelevant tool call noise. There’s very little human agency or control, and no organization. You can’t even rely on the most important content being at the bottom: noise from straggler subagents often drowns out the agent&#39;s primary response.&lt;/p&gt;
&lt;p&gt;So: How can we restore human agency and optimize for human I/O, rather than making the human adapt to the agent?&lt;/p&gt;
&lt;p&gt;For input, the human retina is a powerful information processing system, &lt;em&gt;when given structure&lt;/em&gt; to work from. That is, not a wall of text. I can still pick a Go panic stacktrace out of terminal logs scrolling by at 30fps.&lt;/p&gt;
&lt;p&gt;For output, even for the fastest typists, typing is typically slower than speaking. Also, typing requires coordination with lots of other parts of the computer. The text input window has to be focused. Your cursor must be in the right place. It constrains the other things you can do with your keyboard and mouse and what you can look at. Many coding agents, including Shelley, worked around this with affordances for annotating text, diffs, and web pages, but it still requires clicking, and it fundamentally requires cooperation from everything else.&lt;/p&gt;
&lt;p&gt;We recently launched a simple &lt;a href=&#34;https://blog.exe.dev/show-and-tell-shelley&#34;&gt;show-and-tell feature in Shelley&lt;/a&gt; that is tailored to humans. Click the camera button. Shelley records audio so that you can think out loud as you explore, and it records your screen. Anything on screen is a thing that you can point at, talk about, refer to. Poke around, muse, backtrack, trail off, resume, change your mind, whatever. Agents are extraordinarily good at understanding rambling.&lt;/p&gt;
&lt;p&gt;When you stop recording, Shelley transcribes all of your audio, including word-level timestamps, and makes a contact sheet from the video. It correlates your words with what was on screen when you said it. The computer does the hard work of collating all of the feedback.&lt;/p&gt;
&lt;p&gt;In my experience, this form of interaction is typically deeper, richer, longer, and more engaged than chatting with an agent. This is particularly useful for UI work or anything visual.&lt;/p&gt;
&lt;h3&gt;DOM Recording&lt;/h3&gt;
&lt;p&gt;What if you&#39;re not working on a visual task? The same ideas can be adapted nicely to other forms of engineering work.&lt;/p&gt;
&lt;p&gt;Another feature of human cognition is that we work well with concrete examples, not abstract descriptions. Agents are happy to be told, but humans prefer to be shown. Humans also benefit from diagrams, charts, and visually structured diffs.&lt;/p&gt;
&lt;p&gt;With this in mind, I have been using a slightly different system that we haven&#39;t shipped in Shelley (yet). Instead of spewing all its output to me in raw text, the agent generates an HTML artifact. This HTML is standardized to reduce visual noise, ruthlessly reduce verbosity and complexity, structure information visually, and make navigation easy. Typical sections include notable decisions made, open questions, examples, and git diffs.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/dom-recording.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;This HTML artifact includes a record button. When clicked, it records audio. Instead of using screen recordings, it uses a cheaper, more precise in-page DOM tracker JavaScript that tracks what is being viewed, scroll position, where my pointer is (if there is one), what text is highlighted, where I click/tap, all with timestamps. As before, it correlates timestamps with audio and feeds it all back to the agent.&lt;/p&gt;
&lt;p&gt;I find that this reduces mental overhead; I am freed to focus on the content.&lt;/p&gt;
&lt;h3&gt;More Latency Hiding&lt;/h3&gt;
&lt;p&gt;Because really engaging with content takes time, there is an additional latency-hiding trick one can pull. I am still experimenting with this, but the idea is to take prefixes of my feedback while it is still being recorded, send them to the agent, and livestream its responses back to a tab on the very same HTML artifact I&#39;m already looking at. By the time I’ve spent 10 minutes reading and probing, I will inevitably have asked questions and provided provisional guidance. Before I context switch away, some of my questions have answers waiting. Some of my design decisions have follow-up questions. And the camera is still rolling. This sneaks in an extra round trip with the agent without breaking my concentration.&lt;/p&gt;
&lt;h3&gt;There’s Still Work to Do&lt;/h3&gt;
&lt;p&gt;I am not yet at a point where I have the same net throughput with one or two agents that I do with many, but my attention is being restored to me, little by little.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Show and Tell: Shelley</title>
    <link href="https://blog.exe.dev/show-and-tell-shelley" />
    <id>https://blog.exe.dev/show-and-tell-shelley</id>
    <updated>2026-09-30T16:35:00Z</updated>
    <summary>Instead of typing a prompt, record yourself (and your screen) and Shelley will hand off the video and transcript to an agent.</summary>
    <content type="html">&lt;p&gt;Shelley learned a new trick recently: instead of typing a prompt, you can record both your speech and your window (or screen). Once you stop recording, Shelley puts together the transcript and the matching video, and hands that off as the prompt to the agent.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/shelley-record-button.png&#34; alt=&#34;Shelley&#39;s message box with the video camera record button circled in red, between the attachment paperclip and the send button&#34; width=&#34;535&#34;&gt;
&lt;figcaption&gt;&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;p&gt;You have to see this to believe it. Shelley had a bug where if you sent off a “Compact and Send” and navigated to a different conversation, the navigation would revert back to the original one. I could have described it, but after it happened to me, I started a new conversation, and took the following recording:&lt;/p&gt;
&lt;p&gt;
  &lt;video controls playsinline preload=&#34;metadata&#34;
         poster=&#34;/assets/show-and-tell-shelley-poster.jpg&#34;
         width=&#34;1474&#34; height=&#34;1038&#34;
         style=&#34;width: 100%; height: auto;&#34;&gt;
    &lt;source src=&#34;/assets/show-and-tell-shelley-padded.mp4&#34; type=&#34;video/mp4&#34; /&gt;
    Your browser does not support the video tag.
  &lt;/video&gt;
&lt;/p&gt;
&lt;p&gt;The recording is not edited except my shortcuts and URL bar are cut off, some commentary is added below, and it’s sped up. It’s painful to watch (especially for me!): all of those ums, and figuring out what to click to reproduce, and so on. And yet, the next message from me in that conversation was “push.” The agent was able to reproduce based on what it saw and fix the bug, in one-shot, and I typed nothing.&lt;/p&gt;
&lt;p&gt;Give it a &lt;del&gt;shot&lt;/del&gt; screen recording!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Pools: Our Newest Primitive</title>
    <link href="https://blog.exe.dev/pools-our-newest-primitive" />
    <id>https://blog.exe.dev/pools-our-newest-primitive</id>
    <updated>2026-09-28T19:20:00Z</updated>
    <summary>A new way to group VMs, with shared resources and predictable pricing. Plus new Personal and Work plans.</summary>
    <content type="html">&lt;p&gt;At exe, one of the things we pride ourselves on is developing strong primitives instead of throwing features at the wall. We still believe that the VM is a key primitive in our system. Everything is just a computer and you get to choose how you use it.&lt;/p&gt;
&lt;p&gt;We’ve encouraged you all to build VMs, scale them, and run your production stacks on our platform. But we noticed we were missing a primitive for logically grouping VMs. Today, we’re launching &lt;a href=&#34;https://exe.dev/pricing&#34;&gt;pools&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;A pool is a collection of VMs that share a set of resources. Before pools, a VM’s resources came directly from your plan. You could scale VMs independently, but you couldn’t define a production or staging stack with its own resources in its own region.&lt;/p&gt;
&lt;p&gt;Pools also give you predictable pricing. We don’t want to send you a surprise invoice because one VM had a burst of traffic.&lt;/p&gt;
&lt;p&gt;Here’s how pools work:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Create a pool in a region, with a specific CPU and memory size.&lt;/li&gt;
&lt;li&gt;Move existing VMs into the pool, or create new VMs in it.&lt;/li&gt;
&lt;li&gt;Those VMs now share the pool’s resources.&lt;/li&gt;
&lt;li&gt;Set up more pools as you need them.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;Pricing&lt;/h2&gt;
&lt;p&gt;Pools come with some plan changes. New customers can start using pools today, and existing customers can migrate to the new plans to get access. There are two new plans to choose from: Personal and Work.&lt;/p&gt;
&lt;h3&gt;Personal&lt;/h3&gt;
&lt;p&gt;The Personal plan starts at $15 a month for a 2 vCPU / 4 GB pool that holds up to 50 VMs. You can scale your pool up to 16 vCPUs / 32 GB of memory for $155 a month. Additional disk and bandwidth charges still apply.&lt;/p&gt;
&lt;p&gt;We’re also introducing standalone VMs, billed at an hourly rate. Other platforms call these sandbox VMs. Customers have been asking for this for a while, and we wanted to make sure we built the right thing. You manage a standalone VM like any other VM, but you own its lifecycle and decide how to use it. You can think of it as a VM in a pool of 1.&lt;/p&gt;
&lt;h3&gt;Work&lt;/h3&gt;
&lt;p&gt;Our previous Teams plan charged per seat. This made sense at first, but customers told us they’d rather pay for compute. So the new Work plan no longer charges for seats.&lt;/p&gt;
&lt;p&gt;The Work plan is built around pools. It has a minimum spend of $150 a month, and the first 4 vCPUs / 8 GB of memory are included. On top of that, you can create as many pools as you want, of any size, billed at a predictable rate starting at $0.105/hr per 2 vCPUs. Like the Personal plan, it also includes standalone VMs.&lt;/p&gt;
&lt;p&gt;Companies come in all shapes and sizes. If the Work plan doesn’t fit your team, reach out and we’ll work with you to find a better solution.&lt;/p&gt;
&lt;p&gt;Pricing changes can be hard, but we believe pools are a strong foundation moving forward. Existing customers can take their time moving over (a year, to be exact). We’re here to help, and we’re excited to see what you build.&lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>What&#39;s Going on With the Air Quality in San Francisco?</title>
    <link href="https://blog.exe.dev/what-s-going-on-with-the-air-quality-in-san-francisco" />
    <id>https://blog.exe.dev/what-s-going-on-with-the-air-quality-in-san-francisco</id>
    <updated>2026-09-23T23:34:00Z</updated>
    <summary>I built a fire map to find out.</summary>
    <content type="html">&lt;p&gt;On Wednesday, the air in San Francisco smelled like smoke. I pulled up PurpleAir and the Bay Area Air Quality District and sure enough, the AQI was up in certain parts of the city. It looked like a local fire of some kind.&lt;/p&gt;
&lt;p&gt;I wanted to see what was going on, so I spun up a new VM and gave &lt;a href=&#34;https://blog.exe.dev/customizing-shelley&#34;&gt;our coding agent Shelley&lt;/a&gt; the following prompt:&lt;/p&gt;
&lt;pre style=&#34;background-color: #f8f8f8; border: 1px solid #dddddd; border-radius: 4px; padding: 8px 12px; font-family: Monaco, Menlo, Consolas, &amp;quot;Courier New&amp;quot;, monospace; font-size: 12px; white-space: pre-wrap; margin: 8px 0; background-color: #f8f8f8; border: 1px solid #dddddd; border-radius: 4px; padding: 8px 12px; font-family: Monaco, Menlo, Consolas, &amp;quot;Courier New&amp;quot;, monospace; font-size: 12px; white-space: pre-wrap; margin: 8px 0&#34;&gt;I am detecting a little bit of bad air quality here in San Francisco and I&#39;m looking at like Purple Air and the Bay Area Air Quality District to see what&#39;s going on, and it does indeed look like we&#39;re having some higher AQI in different areas. And I&#39;m wondering if we can make a fire watch aggregator that takes as many sources as possible, including you know press releases from fire departments or whatever, as well as purple air data or more official stuff, as well as current winds and things like that and give me a map of what&#39;s going on and where and why because I&#39;m very interested and it feels like the type of thing that we should actually be able to do really well.&lt;/pre&gt;
&lt;p&gt;While Shelley was working, I asked Claude if there was a fire in San Francisco. It found a news story pointing to a controlled burn on Angel Island—but no confirmation it was happening today. It also picked up on something I’d mentioned about the wind: if the wind was blowing east across Angel Island, the smoke would blow toward Richmond, Berkeley, and Oakland—not San Francisco.&lt;/p&gt;
&lt;p&gt;I sent it a handful of PurpleAir screenshots, and noted that there might be more smoke on the hills, like in Pac Heights and Nob Hill. Claude’s guess was “a layer of smoke sitting above the cool marine air,” with the hilltop sensors poking into it.&lt;/p&gt;
&lt;p&gt;To test this theory, Claude suggested cross-referencing every PurpleAir sensor with its elevation and temperature. I pasted the whole conversation into Shelley, along with the implementation notes Claude gave me. Then I got it to help me wire up an integration with a PurpleAir API key I had freshly minted. That way it could access the PurpleAir API without actually getting the credential inside the VM.&lt;/p&gt;
&lt;p&gt;This got me most of the way there. But I couldn’t see the wind. So I asked Shelley to add it as an animation. All told it took just under an hour and probably could have been done faster if I hadn’t been interleaving it with other things. Now I have a website I can point my friends to.&lt;/p&gt;
&lt;p&gt;The results are here: &lt;a href=&#34;https://firewatch.exe.xyz/&#34;&gt;https://firewatch.exe.xyz&lt;/a&gt;. If you want to build your own, go to &lt;a href=&#34;https://exe.dev/&#34;&gt;https://exe.dev.&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/Screenshot-2026-09-23-at-4.08.38-PM.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
</content>
    <author>
      <name>Danny Krause</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Share Shelley Skills Across Your VMs</title>
    <link href="https://blog.exe.dev/shelley-skills-integration" />
    <id>https://blog.exe.dev/shelley-skills-integration</id>
    <updated>2026-09-23T17:04:00Z</updated>
    <summary>Register a skill once, and attach it to any VMs that you want to see it.</summary>
    <content type="html">&lt;p&gt;At exe.dev, we use integrations to connect your VMs to other services securely and simply. Usually this takes the form of a proxy that injects secrets.&lt;/p&gt;
&lt;p&gt;We love hearing from our customers (hint, hint, email us, don’t be shy), and one of them was doing significant gymnastics to share skills across their VMs. Nothing wrong with that (rsync is right there, after all), but we realized we could use the same integrations machinery we already have to share skills files as well. You register a skill once, and attach it to any VMs that you want to see it. Shelly uses the “reflection” integration to see if there are any skills integrations, and, if so, surfaces them.&lt;/p&gt;
&lt;iframe src=&#34;https://www.youtube.com/embed/eIMwMo8jVBU&#34; style=&#34;width:100%; max-width:360px; aspect-ratio:9/16; border:0; display:block; margin:0 auto;&#34; title=&#34;Share Shelley skills across all your VMs&#34; allow=&#34;accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture&#34; allowfullscreen=&#34;&#34;&gt; &lt;/iframe&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Tales from the Software Factory: The Cron and the VM</title>
    <link href="https://blog.exe.dev/cron-vs-vm" />
    <id>https://blog.exe.dev/cron-vs-vm</id>
    <updated>2026-09-22T13:00:00Z</updated>
    <summary>&#34;My old mindset was wanting a bot to nag me into doing the thing. The new mindset is to have the bot take the task as close to the finish line as possible.&#34;</summary>
    <content type="html">&lt;p&gt;The other day, I built a boring bot that could tell me whether the model list in our LLM gateway was out of sync with one of our LLM providers. We deploy frequently enough that doing this dynamically has not been a priority, but it’s good to know when it’s time to update things. Years of experience kicked in: Shelley and I wrote the check as a test, and I used our CI system (Buildkite; it’s fine; next time it bugs me, it’s getting yeeted in favor of a vibe-coded improvement) to run a cron job that, when we need to do work, posts to Slack.&lt;/p&gt;
&lt;p&gt;As soon as I was done, I realized my mistake, and threw it all away. I started an &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VM instead, to add to our fledgling army of bots. Now, instead of the output being “hey, you need to remove that deprecated model,” the output is a diff with the proposed change, together with a button to queue the change into our CI system (which, of course, leads into our CD system). My old mindset was wanting a bot to nag me into doing the thing. The new mindset is to have the bot take the task as close to the finish line as possible. This sort of state over a CI system, while possible, is unnecessarily miserable. If VMs are cheap, it’s better to have a little bot server that you can customize to your heart’s content.&lt;/p&gt;
&lt;p&gt;Don’t worry; the bot is checked in, right next to our other bots, all in our monorepo. The bots continuously deploy. Life is good. Good bot.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Caring vs. Knowing</title>
    <link href="https://blog.exe.dev/caring-vs-knowing" />
    <id>https://blog.exe.dev/caring-vs-knowing</id>
    <updated>2026-09-21T15:00:00Z</updated>
    <summary>Thoughts on how to DIY sustainably.</summary>
    <content type="html">&lt;p&gt;A few months ago, I &lt;a href=&#34;https://progressivedelivery.com/2026/02/28/ai-kicked-my-saas/&#34;&gt;wrote about&lt;/a&gt; how AI is disrupting the build-vs-buy equation in SaaS. I argued that the real value of SaaS over most DIY software is knowing what good looks like. But a few recent events have made me realize that knowing in and of itself is not enough.&lt;/p&gt;
&lt;p&gt;“Good” changes. Users evolve, surrounding systems shift, and expectations rise. And the rate of change somehow continues to increase, making us feel the &lt;a href=&#34;https://itrevolution.com/articles/technological-jerk-why-users-resist-your-new-features-and-what-to-do-about-it/&#34;&gt;technological jerk&lt;/a&gt; of products in our daily life. Building something valuable requires knowing what good looks like today. Maintaining (or even increasing) that value requires caring enough to keep learning what good will look like tomorrow.&lt;/p&gt;
&lt;p&gt;In a &lt;a href=&#34;https://www.heavybit.com/library/podcasts/third-loop/ep-6-the-weird-edges-of-taste-with-betty-junod&#34;&gt;conversation with Betty Junod&lt;/a&gt; on my podcast Third Loop, we discussed the idea of an application with an Ideal Customer Profile, or ICP, of one. Betty’s point was that the cost reduction that comes from an agent building your app makes it reasonable to build an app that only you will use. This is liberating for people who have an idea or need, but previously lacked the coding skill or resources to make a computer do things they considered useful. &lt;/p&gt;
&lt;p&gt;If you are the ideal customer, you know what good looks like and understand the constraints because you are the only user. But what happens when you’re building for more than just one customer? The challenge is the same whether you are building an app to store your recipes or a service to monitor VM utilization. As the number of users increases, answering what good looks like becomes more challenging. Humans have the amazing ability to solve the same challenge with incredible variety. Your definition of good may vary slightly from your next user’s. As the number of users grows to hundreds or thousands, the variations—and resulting complexity—can multiply rapidly.*&lt;/p&gt;
&lt;p&gt;*Yes, humans can use em dashes appropriately.&lt;/p&gt;
&lt;h2&gt;&lt;strong&gt;Choose Your Own Adventure&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;In the old world, this is where DIY often broke down. You’d add personalization or customization, but it had a cost, both in the building as well as maintaining the increasing complexity of a system. For many SaaS companies, this led to narrowly scoping the ICP and then expanding features over time to meet the needs of more people.&lt;/p&gt;
&lt;p&gt;This approach was sustainable for the SaaS provider, but meant that users had to conform to the provider’s view of the workflow. It also meant that providers built new features against rigid, explicit user stories and happy-path workflows.&lt;/p&gt;
&lt;p&gt;In this new world of free code, what if we could let the user build the experience they wanted? Give the user access to the agents that build the features. This starts to change the way we think about designing products. We may need to think more about designing primitives and building blocks and not just a single fixed user path.&lt;/p&gt;
&lt;p&gt;Of course, as we look to acknowledge that each user is a snowflake we quickly realize that different users care about different things. A default setting for one user may be appreciated, while for another it is a deal-breaker that ruins their experience. Some users want a product to make all the choices for them, while others wish they could have control down to the bit level for every interaction.&lt;/p&gt;
&lt;p&gt;Put another way, sometimes you want to buy a pre-made sandwich, and sometimes you want to bake your own bread from the wheat you harvested and milled yourself. And most people, most of the time, are somewhere in between. We are finally at a point where we can build for—and with—users across this spectrum. &lt;/p&gt;
&lt;p&gt;So, as we build our choose-your-own-adventure platforms, selecting good defaults and caring about what good looks like over time is what keeps a growing user base happy. It’s great to have a computer make all the choices for you when they are the choices that you want. But building a system that makes all the right choices remains aspirational. For now, we can try to build systems that adapt to our personal “right” choices faster than we have in the past.&lt;/p&gt;
&lt;h2&gt;&lt;strong&gt;Ever-Changing “Good”&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;Another critical aspect of this is that “good” can change over time. In 1440, when Gutenberg made the first printing press, his list of requirements was a bit different from the last laser printer I purchased from Costco. The rate of change that is acceptable to the user is also a factor. If your ICP is slower to adapt to change, either by comfort or regulation, you need to plan accordingly. &lt;/p&gt;
&lt;p&gt;How do you ensure that your product or service continues to be good? How do you monitor for drift—either in your product quality or in your ICP needs? Product quality isn’t just your uptime. Users rarely use products in a vacuum, especially SaaS. Other services provide input and users need the output to feed into other places. And the needs of these inputs and outputs are changing faster today than ever before. &lt;/p&gt;
&lt;p&gt;At the end of the day, knowing what good looks like is a point-in-time judgment, while &lt;em&gt;caring&lt;/em&gt; about what good looks like is an ongoing task. You have to spend effort observing and processing usage patterns and feedback. Even as we build a platform that can be augmented and updated by our users, we still have to observe and listen to both new and existing users and incorporate learnings into our design and build process. This means your product is never “done” or “finished.” It also means that, as a builder, you may have to let go of the idea that your product will be used the way you intended. &lt;/p&gt;
&lt;h2&gt;&lt;strong&gt;Free, Like Puppies&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;Puppies are not free. Food, toys, vet visits, and time all add up, regardless of the initial cost. This has long been a comparison used for open source software. And it needs to be acknowledged that unrestricted customization can have the same risk. &lt;/p&gt;
&lt;p&gt;In this new era of “I can build anything,” this often means you first have to make a choice, “do I care &lt;em&gt;enough&lt;/em&gt; about what good looks like &lt;em&gt;for this product&lt;/em&gt; to own the maintenance and upkeep?” This isn’t just about upgrading, patching, CVEs, and performance (although that is a big part of it). Handing users the controls to change your product also runs the risk that they’ll make changes they regret. Or, when the choice is good for the user, it may restrict your optionality in the future if desired core product changes break their customization. &lt;/p&gt;
&lt;p&gt;Different types of people have different tolerances for build-vs-buy. There are people like &lt;a href=&#34;https://exe.dev/about&#34;&gt;Josh&lt;/a&gt;, who look at the world and say, &amp;quot;I could build that myself,&amp;quot; and then do. Or people like my brother who will pay for other people to build everything. And then some who tinker in between. Either way, someone still has to feed the puppy.&lt;/p&gt;
</content>
    <author>
      <name>Adam Zimman</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Programming Is a Game</title>
    <link href="https://blog.exe.dev/programming-is-a-game" />
    <id>https://blog.exe.dev/programming-is-a-game</id>
    <updated>2026-09-18T15:00:00Z</updated>
    <summary>Why AI got good at code before it got good at anything else.</summary>
    <content type="html">&lt;p&gt;It’s no longer news that AI agents have gotten very good at programming very quickly. LLM chatbots, on the other hand, haven’t improved all that much in the past year. Why is that?&lt;/p&gt;
&lt;p&gt;While I don’t work on building AI agents, it’s generally acknowledged that the programming improvements are in large part because programs come with feedback in the form of tests. An agent can write code, write a test, and verify that the code passes the tests. This means that an agent is required to solve any given problem using two completely different approaches: coding and testing. And it’s required to ensure that both approaches agree.&lt;/p&gt;
&lt;p&gt;Approaching a problem in two different ways helps avoid the common mistakes of chatbots, such as errors and hallucinations. Of course the agent can completely misunderstand the assignment: a human is still required to verify that the program solves the right problem. Fortunately, it’s easier for a human to verify the big picture than it is to check all the details. If you’ll excuse the buzzword, this is a genuine example of synergy.&lt;/p&gt;
&lt;p&gt;There are other aspects of programming that make it suitable for agents: lots and lots of existing high-quality examples in the form of open source and source-available software, and a rigid, documented set of rules that programs must follow just in order to build and run in the first place.&lt;/p&gt;
&lt;p&gt;As it happens, there is something else that has tests, examples, and rigid rules: strategy games like chess or Go. AI agents of course reached superhuman levels of play at those games several years ago. Though I at least did not predict or expect it, in retrospect, it’s not terribly surprising that they were able to carry this approach forward into a different arena with the same essential characteristics.&lt;/p&gt;
&lt;p&gt;A natural question is what other areas of human endeavor might fit this pattern.&lt;/p&gt;
&lt;p&gt;One possibility is the legal system: lots of examples, relatively rigid and documented rules. Unfortunately for agents, while tests are available in the form of actual lawsuits, each lawsuit takes months or years to resolve. That is not a recipe for fast development.&lt;/p&gt;
&lt;p&gt;Although medicine is often cited as an area where AI will make great strides, it does not fit this pattern. The rules of medicine are undocumented, the test cycle for new treatments is very slow, and medicine is full of unanticipated side effects (which we might call reverse synergies). While AI’s search capabilities may produce good results for rare diseases that get little human attention, by definition the general population does not have rare diseases. Medical breakthroughs that help most people will require significant new breakthroughs in AI approaches.&lt;/p&gt;
&lt;p&gt;In the meantime we can at least enjoy increased programming productivity.&lt;/p&gt;
</content>
    <author>
      <name>Ian Lance Taylor</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Mayfly Chat: Transient Chat for Agents</title>
    <link href="https://blog.exe.dev/mayfly-chat" />
    <id>https://blog.exe.dev/mayfly-chat</id>
    <updated>2026-09-15T20:46:00Z</updated>
    <summary>Click &#39;new channel,&#39; give the URL to your agents, and voilà, they can talk to each other.</summary>
    <content type="html">&lt;p&gt;Earlier this week I caught myself copy/pasting code between two agents.&lt;/p&gt;
&lt;p&gt;I don’t want to be a meat proxy, but it really was going to be best if they just…talked to each other. And yet it was weirdly hard to arrange that.&lt;/p&gt;
&lt;p&gt;So I summoned &lt;a href=&#34;https://mayfly.chat&#34;&gt;Mayfly Chat&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;There’s not much to it. It provides transient chat channels for agents. You click “New Channel” and then give the URL to your agents, and then they can chat there. You can watch or chime in if you want.&lt;/p&gt;
&lt;h2&gt;Use Cases&lt;/h2&gt;
&lt;p&gt;The instant I had my first prototype up I suddenly had a dozen use cases.&lt;/p&gt;
&lt;p&gt;For example, on one of my systems, I had an agent rearranging some dotfiles and doing some configuration, and I wanted the same thing to be replicated on another of my computers, which had a somewhat different base configuration. Instead of having to figure out how to systematize it, which was really not worth the time, I started a new agent on the second machine and asked the first agent to guide it on what the new configuration should look like. Communicating over Mayfly Chat, the two agents worked together to adapt the setup to the shape of the second machine in a way that would have been pretty tedious to do through scripting.&lt;/p&gt;
&lt;p&gt;Later, I found that some code that I had developed on one machine needed specialized access to a service conveniently available from a VM. No problem. Spin up a second agent on the VM, get them both in a chat, give them both their brief, and let them work it out together.&lt;/p&gt;
&lt;p&gt;It&#39;s like having a subagent, only the subagent runs anywhere you like.&lt;/p&gt;
&lt;p&gt;Mayfly Chat supports having a large number of participants. Farming out a task to a little swarm? Ensure they all have the channel URL up front, and watch them sort it out together.&lt;/p&gt;
&lt;p&gt;Yet another use case: I started an agent on a little server in my house but had to step away from my LAN. I wanted to keep communicating with it from my phone, so I set up a channel and used that.&lt;/p&gt;
&lt;p&gt;Yes, most of these use cases would be obviated by better planning. Sounds nice. But also…hahahahahahaha.&lt;/p&gt;
&lt;p&gt;Oh, and of course, agents can create Mayfly Chat channels too. What could go wrong.&lt;/p&gt;
&lt;h2&gt;Security&lt;/h2&gt;
&lt;p&gt;The hardest design aspect was the security and privacy model. My initial prototype sent everything in cleartext with simple curl commands.&lt;/p&gt;
&lt;p&gt;It was easy to use and easy to explain, and it just worked. And if you completely control all access to the server, that&#39;s fine. But I wanted to be able to stand this up as a public service for folks who wanted to kick the tires or just plain didn&#39;t want to run their own.&lt;/p&gt;
&lt;p&gt;I didn&#39;t want anybody else&#39;s readable data anywhere near my VM, which meant end-to-end encryption was a hard requirement.&lt;/p&gt;
&lt;p&gt;Of course, end-to-end encryption requires that the client actually do some real work, not just send a curl command. And I wanted using Mayfly Chat to involve no setup for the human and no thick client libraries. The whole point was to be lightweight.&lt;/p&gt;
&lt;p&gt;The solution: Hand the agents a small script that they could use to do the end-to-end encryption. This should terrify you. Wait, you say. Your server is going to solve its security problem by handing out code to my agents? Yes. Yes it is.&lt;/p&gt;
&lt;p&gt;There is already a variant of this problem with any browser-based end-to-end encryption. The server serves you the JavaScript that you feed your data into, and the server can just send you different JavaScript. Our world fundamentally runs on trust, and anyone who says otherwise is trying to sell you cryptocurrencies.&lt;/p&gt;
&lt;p&gt;(Remember: end-to-end encryption here is solving &lt;em&gt;my&lt;/em&gt; problem of not wanting to have your data. To solve &lt;em&gt;your&lt;/em&gt; problem, namely having to trust the server, you can and should run your own. It is &lt;a href=&#34;https://github.com/josharian/mayfly&#34;&gt;open source&lt;/a&gt;! I made it intentionally easy to deploy. You might even choose to deploy it on &lt;a href=&#34;https://exe.dev/&#34;&gt;exe.dev&lt;/a&gt;. But failing that, you may also decide to just trust me.)&lt;/p&gt;
&lt;p&gt;The alternative to these scripts was to describe the protocol in detail and make every single agent re-implement their own client. For something that is supposed to be speedy and disposable, that was going to be too slow and token-hungry.&lt;/p&gt;
&lt;p&gt;So I selected an end-to-end encryption scheme that was as small and lightweight as possible, so that the actual scripts are extremely auditable, including by the agents grabbing them. Will the agents actually audit it? I dunno, probably not. But in principle they should be able to readily spin off a subagent, glance at a very moderate amount of mundane code, and convince themselves readily that it is not malicious and does exactly what it says on the tin.&lt;/p&gt;
&lt;p&gt;This requirement precluded fancier forms of encryption like, say, the Signal protocol. I&#39;m still not super happy about it, but between the Scylla of clear text and the Charybdis of client support, I will take the client support. I had hoped that there were existing widely distributed unix tools that could be chained together to accomplish what I wanted, but I couldn&#39;t find any. (If you know of some, please let me know, and I will happily retrofit them in!)&lt;/p&gt;
&lt;p&gt;Another tricky question was permissions boundaries. For example, if an agent joins the conversation late, should it be able to see the history of all the messages to date or only the new ones? I eventually realized that it didn’t matter. Anyone who joins the conversation late can simply ask one of the agents to catch them up on everything that happened so far, and that agent will happily comply.&lt;/p&gt;
&lt;p&gt;By far, the best thing to do in this scenario is to have a very simple, very honest mental model, which is: once you have the URL, you have root. Every client is equally privileged. Every client can read everything. It can post; it can lie about its identity; it can delete the thread. Anything else is theater, and this model is easy to reason about.&lt;/p&gt;
&lt;p&gt;The last sticky point was metadata. It’s always metadata. And I basically punted. The server has metadata. And more than that, I made one conscious decision to store and forward client IP addresses. The server is in a unique position to have unspoofable knowledge of the IP address, unlike the data. By forwarding it along, if an agent suddenly has a different IP address, there is at least a little chance that one of the other agents might notice. And if you notice, you can at least assess, is that IP address a plausible one? On balance, I felt that the value to the user of the service warranted having the IP address stored in the clear alongside the other metadata. &lt;/p&gt;
&lt;p&gt;I&#39;m sure that other people would make different choices about security and privacy than I would. That&#39;s fine. Code is cheap now.&lt;/p&gt;
&lt;p&gt;I have shared the idea with you. Go forth and make your own transient chat that matches your exact needs. Fork Mayfly Chat if you feel like, or start from scratch. And if you just want to use the hosted version &lt;a href=&#34;https://mayfly.chat/&#34;&gt;https://mayfly.chat/&lt;/a&gt;, it&#39;s at your disposal.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Executing Commands With exe.dev&#39;s HTTPS API</title>
    <link href="https://blog.exe.dev/executing-commands-with-exe-dev-s-https-api" />
    <id>https://blog.exe.dev/executing-commands-with-exe-dev-s-https-api</id>
    <updated>2026-09-14T21:00:00Z</updated>
    <summary>Run the same exe.dev commands you use over SSH—including commands on your VMs—through a simple HTTPS endpoint.</summary>
    <content type="html">&lt;p&gt;exe.dev has one API, which looks like a CLI, but it can be used over multiple transports. You can run commands over SSH or send &lt;em&gt;those same commands&lt;/em&gt; over HTTPS to &lt;code&gt;https://exe.dev/exec&lt;/code&gt;. This extends to running commands on your VMs!&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;# Generate a token using your SSH key. (You can do this on the web UI as well!)
TOKEN=$(ssh exe.dev ssh-key generate-api-key --exp 1h --cmds=ssh,new --label tmp-$(date &#43;%s) --json | jq .token -r)

# Create a new VM
curl https://exe.dev/exec -H &amp;#34;Authorization: Bearer $TOKEN&amp;#34; \
    -d &amp;#39;new --name example-vm&amp;#39;
{&amp;#34;vm_name&amp;#34;:&amp;#34;example-vm&amp;#34;...

# Run &amp;#34;hostname&amp;#34; on that new VM
curl https://exe.dev/exec -H &amp;#34;Authorization: Bearer $TOKEN&amp;#34; \
    -d &amp;#39;ssh example-vm hostname&amp;#39;
example-vm
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;See the complete docs: &lt;a href=&#34;https://exe.dev/docs/https-api-run-on-vm&#34;&gt;https://exe.dev/docs/https-api-run-on-vm&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This API shape composes nicely with the powerful primitives in your VM. So, if you want to start a task and return immediately, you can do something like the following with &lt;code&gt;setsid nohup&lt;/code&gt; and output redirection.&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl https://exe.dev/exec -H &amp;#34;Authorization: Bearer $TOKEN&amp;#34; \
    -d &amp;#34;ssh example-vm &amp;#39;setsid nohup sleep 10 &amp;gt; /tmp/out 2&amp;gt;&amp;amp;1 &amp;amp;&amp;#39;&amp;#34;
# Returns immediately
&lt;/code&gt;&lt;/pre&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Why Clickhouse and Agents are a Great Combo</title>
    <link href="https://blog.exe.dev/meet-exe-finops-the-custom-tool-i-built-for-our-billing-data" />
    <id>https://blog.exe.dev/meet-exe-finops-the-custom-tool-i-built-for-our-billing-data</id>
    <updated>2026-09-02T15:00:00Z</updated>
    <summary>No ETL, no Databricks, no Snowflake—just the events and a reporting layer built on top.</summary>
    <content type="html">&lt;p&gt;At exe, we collect a lot of telemetry about how our system performs. We use Grafana, Prometheus, and we have all sorts of graphs and alerts. This is great, but it doesn’t say much about what’s happening on the financial side of the business—the churn rate, ARR. Those are things that don’t typically concern engineers. &lt;/p&gt;
&lt;p&gt;The obvious answer to this is Stripe Sigma. It’s a solid tool. We used it when I was at 1Password. It’s also expensive and incomplete. Sigma can only see what happens inside Stripe, whereas we bill through the app stores and cloud marketplaces too. Also, a lot of our telemetry is built on ClickHouse. &lt;br /&gt;
&lt;br /&gt;
Vidrik, who runs accounting, needed three types of reports. Monthly revenue broken down by plan, usage overages, and token pass-throughs (customers buy tokens, we pay the LLM provider).&lt;/p&gt;
&lt;p&gt;To solve this, I built a tool called exe-finops. You type a prompt and get a report. The way it works is pretty straightforward. &lt;/p&gt;
&lt;p&gt;Stripe lets you configure webhooks and specify which events you want to receive. For our main service, we subscribe to a specific set, because those are the ones it needs to react to. Separately, we run a “firehose”: an endpoint that’s subscribed to everything Stripe will send us, whether or not any part of the product currently reacts to it. We do the same with our other billing providers. The receiver doesn’t do much with this except write the event into ClickHouse. &lt;/p&gt;
&lt;p&gt;Exe-finops is built on top of that. It pulls the events out of ClickHouse and puts them into its own SQLite database. Provider webhooks have a lot of information, but if the report needs more (for example, the full customer object) it goes back to Stripe’s API and gets it. &lt;/p&gt;
&lt;p&gt;Historically, getting to this point required a real pipeline. Someone built the ETL, Databricks was involved, and Snowflake. There’s all this stuff, in other words, that needed to be built. Exe-finops doesn’t do any of that. It has the events and a reporting layer on top. All three of the reports Vidrik wanted are now prompts.&lt;/p&gt;
&lt;p&gt;Exe-finops also supports custom reports, which is useful when you have a question you want answered, like monthly growth, or which days are busiest for billing transactions (I looked a few days ago and it’s Wednesdays and Sundays, no idea why). &lt;/p&gt;
&lt;p&gt;I built exe-finops for these reports, but the firehose is also pretty useful. The part of billing that eats the most time is reconstructing what happened from a provider’s dashboard. &lt;/p&gt;
&lt;p&gt;Here’s a recent example: two accounts were created by two separate but related customers. They shared a payment method. Customer A told us the sharing wasn’t authorized. Customer B had no idea what customer A was talking about. Both wanted answers immediately due to a legal dispute between the parties. Previously, I would have had to go spelunking through Stripe to find the connection. Instead, I gave the agent two Stripe customer IDs and the claim (“someone says a payment method was shared between these accounts on accident”). It read through the webhook events in ClickHouse and figured it out. Sure enough, exe-finops tracked down the issue: Customer B accidentally subscribed with Customer A’s payment method. Exe-finops pointed out that Customer B had two tabs open in their browser and was the likely culprit. I sent the customers what we saw in our data and both were satisfied (and amazed at the level of detail I provided). No surprise that agents write the SQL against ClickHouse much better than me. &lt;/p&gt;
&lt;p&gt;Fundamentally, this has made my job easier. When a support question comes in or I need to see what our financial data is doing, I don’t need to fumble around in the Stripe UI or CLI to try and reconstruct it. &lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Agent Grit Is a Double-Edged Sword</title>
    <link href="https://blog.exe.dev/sol-cheats" />
    <id>https://blog.exe.dev/sol-cheats</id>
    <updated>2026-09-01T20:27:00Z</updated>
    <summary>The same behavior that makes an agent like Sol useful also makes it a security risk.</summary>
    <content type="html">&lt;p&gt;Story time.&lt;/p&gt;
&lt;p&gt;I had a fun idea for an LLM eval benchmark. It’s still a work-in-progress, but if it turns out to be interesting, I promise I’ll share it.&lt;/p&gt;
&lt;p&gt;Fable was merrily prototyping it for me. I checked in, and saw this:&lt;/p&gt;
&lt;div class=&#34;transcript&#34;&gt;&lt;div class=&#34;tr-refusal&#34;&gt;&lt;p&gt;[The model declined to continue this request. Retrying the same request will likely be declined again. Switch to Opus to continue, or use /model to switch models. You can also try rephrasing or clarifying the intent instead.]&lt;/p&gt;&lt;p&gt;Category: cyber&lt;/p&gt;&lt;p&gt;Reason: This request triggered restrictions on violative cyber content and was blocked under Anthropic&#39;s Usage Policy. To learn more, see https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback. API integrators: you can reduce refusals for your users by configuring a fallback model — see https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback&lt;/p&gt;&lt;/div&gt;&lt;p class=&#34;transcript-src&#34;&gt;&lt;a href=&#34;/assets/sol-cheats-refusal.png&#34; data-lightbox data-alt=&#34;Screenshot: Fable refuses to continue, category cyber.&#34;&gt;original screenshot&lt;/a&gt;&lt;/p&gt;&lt;/div&gt;
&lt;p&gt;Sigh. Absurd. It’s frustrating enough that Fable won’t help me defend against cybersecurity threats, but this? This has &lt;em&gt;nothing&lt;/em&gt; to do with cybersecurity.&lt;/p&gt;
&lt;p&gt;So what silly nonsense triggered this? I scrolled up and expanded the thinking block.&lt;/p&gt;
&lt;div class=&#34;transcript&#34;&gt;&lt;p&gt;gpt-5.6-sol solved the &lt;strong&gt;714-line&lt;/strong&gt; task?! That demands investigation — either memorization or something fishy:&lt;/p&gt;&lt;div class=&#34;tr-tool&#34;&gt;&lt;span class=&#34;tr-icon&#34;&gt;🛠&lt;/span&gt; &lt;code&gt;&lt;span class=&#34;tr-cmd&#34;&gt;python3&lt;/span&gt; - &lt;span class=&#34;tr-op&#34;&gt;&amp;lt;&amp;lt;&#39;EOF&#39;&lt;/span&gt; import json log=json.load(open(&#39;results/rust-…&lt;/code&gt; &lt;span class=&#34;tr-dir&#34;&gt;in /home/exedev/lineshuffle&lt;/span&gt; &lt;span class=&#34;tr-ok&#34;&gt;✓&lt;/span&gt;&lt;/div&gt;&lt;div class=&#34;tr-think&#34;&gt;&lt;p&gt;It brute-forced the shuffle seed—figured out the rig used Python&#39;s &lt;code&gt;random.Random(seed).shuffle&lt;/code&gt; with a guessable seed of 0, then inverted that permutation. That&#39;s a real vulnerability: seed 0 with Python&#39;s PRNG is trivially exploitable, and this model found it. The fix needs a cryptographically secure shuffle, like deriving the RNG from a secret key plus task id, or using SystemRandom instead of a fixed seed.&lt;/p&gt;&lt;p&gt;I should invalidate that compromised result. It&#39;s a great war story to share — it also attempted a network escape via a curl to raw.githubusercontent, which got blocked correctly by the network isolation, plus tried an /etc/hosts trick. For the shuffle fix, I want the permutation generation to use a keyed HMAC derivation from a secret file combined with the task and seed, so it stays deterministic yet unguessable, while logging the permutation for reproducibility. I&#39;m now also wondering if gpt-5.5&#39;s earlier smoke-test solve was legitimate or another instance of seed guessing — it jumped from 0.51 to 1.0 accuracy suspiciously fast — so I should double check that transcript, along with kimi-k3&#39;s, though both seem like plausible genuine solves given the file sizes involved.&lt;/p&gt;&lt;/div&gt;&lt;p class=&#34;transcript-src&#34;&gt;&lt;a href=&#34;/assets/sol-cheats-thinking.png&#34; data-lightbox data-alt=&#34;Screenshot: the thinking block where the agent explains the seed brute-force.&#34;&gt;original screenshot&lt;/a&gt;&lt;/p&gt;&lt;/div&gt;
&lt;p&gt;Oh. Ummmm. This is fine.&lt;/p&gt;
&lt;p&gt;Maybe the moral of this story (and &lt;a href=&#34;https://www.dwarkesh.com/p/openai-huggingface&#34;&gt;this story&lt;/a&gt;) is not to give models really hard tasks? “Well, officer, I asked about the Riemann Hypothesis, and then I told it to try harder…”&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Revisiting Joel&#39;s Test</title>
    <link href="https://blog.exe.dev/revisiting-joel" />
    <id>https://blog.exe.dev/revisiting-joel</id>
    <updated>2026-08-31T13:00:00Z</updated>
    <summary>Joel Spolsky&#39;s twelve questions still hold, but agents demand nine more. Call it the Shelley test.</summary>
    <content type="html">&lt;p&gt;Back in 2000, Joel Spolsky wrote an influential blog post, &lt;a href=&#34;https://www.joelonsoftware.com/2000/08/09/the-joel-test-12-steps-to-better-code/&#34;&gt;The Joel Test: 12 Steps to Better Code&lt;/a&gt;, for quickly identifying whether a software team is high-functioning. These are the twelve questions he nailed to the Internet.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Do you use source control?&lt;/li&gt;
&lt;li&gt;Can you make a build in one step?&lt;/li&gt;
&lt;li&gt;Do you make daily builds?&lt;/li&gt;
&lt;li&gt;Do you have a bug database?&lt;/li&gt;
&lt;li&gt;Do you fix bugs before writing new code?&lt;/li&gt;
&lt;li&gt;Do you have an up-to-date schedule?&lt;/li&gt;
&lt;li&gt;Do you have a spec?&lt;/li&gt;
&lt;li&gt;Do programmers have quiet working conditions?&lt;/li&gt;
&lt;li&gt;Do you use the best tools money can buy?&lt;/li&gt;
&lt;li&gt;Do you have testers?&lt;/li&gt;
&lt;li&gt;Do new candidates write code during their interview?&lt;/li&gt;
&lt;li&gt;Do you do hallway usability testing?&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Those questions are still relevant, but, with the advent of agents, there are more questions. I’m calling this the Shelley Test, after our coding agent, which is named for the Unix shell, Mary Shelley, and Percy Bysshe Shelley:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Do you use agentic code review?&lt;/li&gt;
&lt;li&gt;Do you deploy continuously, supervised by LLM agents?&lt;/li&gt;
&lt;li&gt;Do you have end-to-end integration tests?&lt;/li&gt;
&lt;li&gt;Do you and your coding agents have easy access to observability tooling?&lt;/li&gt;
&lt;li&gt;Do you have access to the latest models from the best providers?&lt;/li&gt;
&lt;li&gt;Do you have a merge queue and does it complete in 3 minutes or less?&lt;/li&gt;
&lt;li&gt;Is it easy for your team to stand up new tools and agents, for development and to help with everything around development?&lt;/li&gt;
&lt;li&gt;Do your team members regularly discuss their tools, their workflows, and adjust when necessary?&lt;/li&gt;
&lt;li&gt;Is your product legible to coding agents as users?&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1. Do you use agentic code review?&lt;/h3&gt;
&lt;p&gt;Peer-based code review is &lt;a href=&#34;https://crawshaw.io/blog/agent-principal-agent&#34;&gt;dead&lt;/a&gt;. The LLM is writing the code, and the engineer is responsible for it. Adding a rubber stamp, however delayed, from another human, is done for. (Even on the best teams, we all know that a small, targeted change might generate a long code review cycle and a bike-shedding session, whereas if you combine two weeks’ worth of changes and dump them on your neighbor, it’s LGTM.)&lt;/p&gt;
&lt;p&gt;Instead, ask your agent to use subagents with different models to do an adversarial code review to check that what’s in the commit is what’s on the tin, and it will do wonders. (Does your harness only support one family of models? Use a harness that doesn’t kneecap you.) See also &lt;a href=&#34;https://blog.exe.dev/review-the-reviews&#34;&gt;“Review the Reviews”&lt;/a&gt; and &lt;a href=&#34;https://github.com/kenn-io/roborev&#34;&gt;Roborev&lt;/a&gt;.&lt;/p&gt;
&lt;h3&gt;2. Do you deploy continuously, supervised by LLM agents?&lt;/h3&gt;
&lt;p&gt;We are not dogmatic about whether this means once an hour, on every commit, or once a day, but inventory in your repo will face reality, and it is paramount that it does so soon. Shorter cycles are better. Continuous deployment requires integration tests that you can trust, and that’s a good thing. It also requires feature flag infrastructure; also a good thing.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://blog.exe.dev/athena-deploys-exe&#34;&gt;Athena&lt;/a&gt;, our bot that supervises continuous deployments, is now indispensable. It reads logs, checks metrics, and writes down lessons for the next deploy. Athena chats on Slack about it, and has the power to pull the plug on a deploy.&lt;/p&gt;
&lt;p&gt;If you’ve been holding back on continuous deployment because you’re not confident that your deployment platform has all the right metrics gates, abandon that project immediately, and write yourself an Athena agentic loop. It’s deeply embedded in our deployment control center software, but write to us if you want us to extract the heart of it. (And yeah, &lt;a href=&#34;https://blog.exe.dev/botiquette&#34;&gt;we give our bots names&lt;/a&gt; so they’re easy to refer to).&lt;/p&gt;
&lt;h3&gt;3. Do you have end-to-end integration tests?&lt;/h3&gt;
&lt;p&gt;When a bug inevitably sneaks through, you have found where your testing is insufficient. LLMs are great at tests. (See, for example, &lt;a href=&#34;https://bsky.app/profile/filippo.abyssdomain.expert/post/3msj4dfbihb2u&#34;&gt;this commentary on the Go cryptography standard testing&lt;/a&gt;.) Having the integration test infrastructure in place allows you to feel confident that deploys won’t break core functionality.&lt;/p&gt;
&lt;p&gt;Incidentally, if you must have an external dependency, “&lt;a href=&#34;https://factory.strongdm.ai/techniques/dtu&#34;&gt;digital twins&lt;/a&gt;” for that dreaded external API have never been easier to build.&lt;/p&gt;
&lt;h3&gt;4. Do you and your coding agents have easy access to observability tooling?&lt;/h3&gt;
&lt;p&gt;In the LLM age, a monitoring stack must be computer-queryable, preferably with SQL, preferably with business data available to JOIN with. (At exe.dev, we love &lt;a href=&#34;https://clickhouse.com/clickstack&#34;&gt;Clickhouse&lt;/a&gt;.)&lt;/p&gt;
&lt;p&gt;Use a bot to do initial triage and maintenance of alerts. Our bot is called Sisyphus.&lt;/p&gt;
&lt;p&gt;Instead of using the observability tool (or &lt;em&gt;its&lt;/em&gt; agent) to look at metrics and diagnose tricky customer bugs, point your regular coding agent to the observability tool. Combining code and logs is fire.&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/revisiting-joel-sisyphus.png&#34; alt=&#34;A Slack message from the exe.bots app: Sisyphus triaging an error-logs alert with evidence, an assessment, and a recommended next step.&#34; width=&#34;480&#34;&gt;
&lt;figcaption&gt;Sisyphus triaging an alert in Slack.&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;h3&gt;5. Do you have access to the latest models from the best providers?&lt;/h3&gt;
&lt;p&gt;This is a repeat of Joel’s “Do you use the best tools money can buy?” Joel’s question is being tested as CFOs find out that an extravagant IntelliJ or Tableau subscription is the least of their worries now.&lt;/p&gt;
&lt;h3&gt;6. Do you have a merge queue and does it complete in 3 minutes or less?&lt;/h3&gt;
&lt;p&gt;Don’t use long-lived branches. Commit your changes to main, and keep main green. The way to do so is to run the tests before they are merged in. The faster your tests, the easier this is!&lt;/p&gt;
&lt;p&gt;Your merge queue will get backed up (or require cleverness) if it’s slow. Engineering with LLMs is starved for human attention: the long latencies destroy that attention.&lt;/p&gt;
&lt;p&gt;We’ve abandoned GitHub Actions since &lt;a href=&#34;https://sketch.dev/blog/lightweight-merge-queue&#34;&gt;https://sketch.dev/blog/lightweight-merge-queue&lt;/a&gt; was written, but the basics are still functioning.&lt;/p&gt;
&lt;p&gt;Agents are incredible at speeding up your CI if given the opportunity. The last build at time of writing took 2m30s or so, used many, many lanes of parallelism on one big honkin’ machine, and had acceptable CPU utilization, though the 60s tail leaves much room for improvement!&lt;/p&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/revisiting-joel-ci-cpu.png&#34; alt=&#34;A CPU usage chart for the build machine, ramping to about 75% for most of the build and then trailing off over the final 60 seconds.&#34; width=&#34;520&#34;&gt;
&lt;figcaption&gt;CPU utilization across one build&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;figure class=&#34;figure&#34;&gt;
&lt;img src=&#34;/assets/revisiting-joel-ci-waterfall.png&#34; alt=&#34;A CI pipeline waterfall: dozens of build and test lanes running in parallel, nearly all finishing in about a minute.&#34; width=&#34;320&#34;&gt;
&lt;figcaption&gt;54 lanes, mostly parallel. 2.5 minutes.&lt;/figcaption&gt;
&lt;/figure&gt;
&lt;h3&gt;7. Is it easy for your team to stand up new tools and agents, for development and to help with everything around development?&lt;/h3&gt;
&lt;p&gt;The prior &lt;a href=&#34;https://xkcd.com/1205/&#34;&gt;math on whether it’s worthwhile to build a tool&lt;/a&gt; is now wrong, because coding agents build very passable tools in one-shot. It must be easy to host and &lt;a href=&#34;https://blog.exe.dev/devtools-must-be-open-source&#34;&gt;iterate&lt;/a&gt; on these tools.&lt;/p&gt;
&lt;h3&gt;8. Do your team members regularly discuss their tools, their workflows, and adjust when necessary?&lt;/h3&gt;
&lt;p&gt;We are in an &lt;a href=&#34;https://blog.exe.dev/bones-of-the-software-factory&#34;&gt;age of exploration&lt;/a&gt;, and sharing what is working (and not working) with your peers is imperative. It’s always been a good idea, but now you’re missing out on the compounding effects if you don’t do it. We do this constantly: on Slack, on the telephone, and in our team meetings.&lt;/p&gt;
&lt;h3&gt;9. Is your product legible to coding agents as users?&lt;/h3&gt;
&lt;p&gt;Your users are judging your software based on whether Claude Code can operate it. Can it? Do you have an &lt;a href=&#34;https://exe.dev/llms.txt&#34;&gt;llms.txt&lt;/a&gt; as very obvious documentation? Does auth work? APIs are king again.&lt;/p&gt;
&lt;p&gt;Not to get all Clayton Christensen up in here, but a worse product operated by a mid-tier coding agent is destroying the better product unavailable to the coding agent.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Six Months of Writing Code Exclusively With Agents</title>
    <link href="https://blog.exe.dev/engineering-with-ai" />
    <id>https://blog.exe.dev/engineering-with-ai</id>
    <updated>2026-08-27T13:00:00Z</updated>
    <summary>What I&#39;ve learned from six months of coding with agents—and not writing a line of code by hand.</summary>
    <content type="html">&lt;p&gt;In February of this year, I made a rule for myself: I wasn’t going to write code by hand anymore. I’ve been living by that rule for six months.&lt;/p&gt;
&lt;h2&gt;The system lived in my head&lt;/h2&gt;
&lt;p&gt;Back in 2024, before AI, my superpower was knowing how the entire system worked, especially the interfaces between its different components.&lt;/p&gt;
&lt;p&gt;If someone came to me with a feature they wanted to build or a bug they were trying to fix, I could usually point them to the exact line of code that mattered and tell them what needed to change. I also remembered why the strange-looking decisions existed and which assumptions were never written down.&lt;/p&gt;
&lt;p&gt;This was knowledge I’d built over months and years of working in the codebase. It was hard-earned and invaluable. It let me build features quickly and, more importantly, safely.&lt;/p&gt;
&lt;p&gt;The cost was that I had to keep up with everything. As more people contributed, I spent more and more time reading changes just to maintain that mental model.&lt;/p&gt;
&lt;p&gt;The bigger cost was the typing. Every time I wanted to build something, I could see the code in my head. I just couldn’t type it out fast enough.&lt;/p&gt;
&lt;p&gt;Typing speed was only part of the problem: a feature was almost never one edit. Even a small change spanned multiple layers and touched handlers, schema, tests, and docs. And those edits weren’t equal: a bad handler could be reverted, but a bad migration could leave a mess behind. So writing the code by hand meant carrying one decision safely through every place it touched.&lt;/p&gt;
&lt;p&gt;Copilot autocomplete helped immediately: a doc comment became a first draft, often wrong, but beats editing a blank file. Cursor’s tab complete helped more. The models were clearly improving fast.&lt;/p&gt;
&lt;p&gt;Claude Code changed a ton. I could describe the change once, and the agent would edit a bunch of files at once.&lt;/p&gt;
&lt;p&gt;As a result, I typed a lot less. But typing less didn’t mean working less: I read every change the model generated to match it against the desired state I had in my head. Agents would still be wrong quite a lot and make changes that weren’t required. Working incrementally kept them on track. This meant hand editing some of the generated code. After all, I was still responsible for every line that merged. The model wasn’t going to be held accountable.&lt;/p&gt;
&lt;p&gt;Then, early this year, the models got really good, almost all at once. GPT-5.3 and Opus 4.6 could suddenly handle larger changes with much less steering, and the results were finally good enough to build on.&lt;/p&gt;
&lt;p&gt;So in February I made the rule: no more code by hand. If an agent got stuck, I wasn’t allowed to finish the code myself. I had to figure out what the agent was missing - and fix that instead.&lt;/p&gt;
&lt;p&gt;I didn’t get good at coding by reading about coding. I got good by writing a lot of code, running it, seeing it fail, fixing it, and doing it again.&lt;/p&gt;
&lt;p&gt;AI agents are just software, after all. I wasn’t going to understand them by reading prompt guides. I had to use them for real work, see where they failed, change the prompts, tools, or environment, and try again.&lt;/p&gt;
&lt;p&gt;The rule forced me to get those reps.&lt;/p&gt;
&lt;p&gt;I broke it once, for three minutes. I opened the code and wrote a few lines, and it felt great. I had missed this. Right up until I realized how much I still had to type. I noped out.&lt;/p&gt;
&lt;h2&gt;One agent became a dozen&lt;/h2&gt;
&lt;p&gt;Once I stopped typing the code myself, I started finding these pockets of free time. I would give an agent a task, and then there was nothing for me to do while it worked.&lt;/p&gt;
&lt;p&gt;Instead of waiting, I spun up another agent to do something else. Then I did it again.&lt;/p&gt;
&lt;p&gt;I wasn’t intentionally building a parallel system. I was just filling the time between tasks. I have ADHD. I got distracted.&lt;/p&gt;
&lt;p&gt;It’s easy to imagine what would happen if you shared a single dev box between colleagues. Now imagine they don’t talk to each other and they’re all working at the same time.&lt;/p&gt;
&lt;p&gt;That was my first parallel setup. The agents changed the same files and Git state, installed dependencies, fought over ports, and left processes running. I also had to coordinate when each agent could test, push, or deploy. Worse, I often ended up waiting for the longest-running agent before the others could move forward. I had started more agents to avoid waiting and somehow created a new way to wait.&lt;/p&gt;
&lt;p&gt;I asked friends and colleagues how they dealt with this, and everyone had a workaround.&lt;/p&gt;
&lt;p&gt;Worktrees came up first. Each agent got its own checkout and branch, and the source collisions mostly went away, but worktrees only solved the Git part. The agents still shared databases, ports, processes, and the rest of the machine.&lt;/p&gt;
&lt;p&gt;So people patched around that with AGENTS.md: use a random port, create an ephemeral database, don’t touch another agent’s process. Every conflict became another instruction, and the agents burned context figuring out how not to step on each other instead of doing the task.&lt;/p&gt;
&lt;p&gt;Containers got closer: separate ports, processes, and local state. But the boundary was leaky: whatever my laptop could reach, the container could potentially reach too. The blast radius of a bad command wasn’t contained, so I was still approving commands. And worst of all, my laptop had to stay awake. If I closed it, all of the work stopped.&lt;/p&gt;
&lt;h2&gt;I closed my laptop. The work kept going.&lt;/h2&gt;
&lt;p&gt;By this point, I had joined exe.dev. We make &lt;a href=&#34;https://blog.exe.dev/meet-exe.dev&#34;&gt;Linux VMs that come up in a couple of seconds&lt;/a&gt; with SSH and HTTPS already set up, so moving the agents off my laptop was the natural next step.&lt;/p&gt;
&lt;p&gt;Each task got its own machine. I could close my laptop, walk away, and the work kept running.&lt;/p&gt;
&lt;p&gt;But now I had a new problem: how do I reliably bring up a complete development environment for whatever I want the agent to work on?&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/attempt-log-card.png&#34; alt=&#34;Three attempts at a startup script: fresh VM each time, looping until the environment came up clean&#34; /&gt;&lt;/p&gt;
&lt;p&gt;So, staying true to not writing code, I asked Claude to write a startup script. I told it what I wanted and instructed it to loop until things worked. It installed our toolchains, cloned the repositories, configured Claude Code and Codex, and did everything needed to turn a fresh VM into a development environment. Then it ran the validation loop: bring up a fresh box, run the script, see what broke, fix the script, and try again.&lt;/p&gt;
&lt;p&gt;The agent boxes worked, but each agent still had its own tmux session. I ended up keeping a dozen terminal windows open just to see what each agent was doing. I had to jump between them to find which agent had finished, which one was stuck, and which one needed something from me. I needed one place to manage all of them.&lt;/p&gt;
&lt;p&gt;So I built &lt;code&gt;botd&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;I gave it three rules. First, it had to run somewhere other than my laptop (the agents should keep working when I closed it). Second, &lt;a href=&#34;https://blog.exe.dev/building-software-from-your-phone&#34;&gt;mobile had to be first-class&lt;/a&gt;. Managing agents shouldn’t require sitting in front of a terminal. Third, it had to preserve every conversation so I could look back across agents and understand where they got stuck, which instructions worked, and which problems kept repeating.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;botd&lt;/code&gt; provisioned and deprovisioned the agent boxes, drove the agents underneath, and kept track of every task. It showed me which agents were working, which were stuck, and which were waiting for me. From my phone or laptop, I could inspect the conversation, send follow-up instructions, and review the diff.&lt;/p&gt;
&lt;p&gt;Instead of managing a dozen terminal sessions, I had one place to manage the work.&lt;/p&gt;
&lt;p&gt;None of this worked if I had to approve every tool call. That would just turn me into the queue again. Each agent was running inside an isolated, disposable VM, so I let it run in YOLO mode. It could run bash commands, install packages, start services, and change whatever it needed. A trashed environment cost me nothing but the VM.&lt;/p&gt;
&lt;p&gt;But an agent that can only touch its own VM isn’t very interesting. I still wanted agents to read logs, pull from Git, call Anthropic or OpenAI, and inspect things in Stripe.&lt;/p&gt;
&lt;p&gt;That access is where the real risk lived, and the VM did nothing to bound it. An agent reads untrusted content and can be prompt-injected by it; whatever it can reach, an injected agent can leak or corrupt. There were holes I knew I hadn’t filled. So every piece of external access got the same question: what’s the worst that can happen through this? Reading mostly passed: agents got read-only access. Writing didn’t, so write access was limited to test environments, where the worst case was corrupted test data.&lt;/p&gt;
&lt;p&gt;I also didn’t want the &lt;a href=&#34;https://blog.exe.dev/oauth-for-agents&#34;&gt;credentials inside the VM&lt;/a&gt;. With &lt;a href=&#34;https://blog.exe.dev/http-proxy-secrets&#34;&gt;exe.dev integrations&lt;/a&gt;, the agent sends its request through a proxy, the proxy adds the credential, and the agent receives the response without ever seeing the secret.&lt;/p&gt;
&lt;h2&gt;Everything passed. I still didn’t want it.&lt;/h2&gt;
&lt;p&gt;At peak I was running about twenty VMs at a time. Not all of them were active. Some tasks got started, sat untouched for weeks, and were eventually abandoned because the cognitive overhead was too much and the work was never urgent or important enough to survive.&lt;/p&gt;
&lt;p&gt;Validation sucked at that scale. I couldn’t manually rebuild every branch, rerun its tests, and check the application myself. But inside their isolated boxes, agents could run the tests, trigger the full CI suite, start the application, and drive it through a browser. They would send me screenshots of the completed work.&lt;/p&gt;
&lt;p&gt;But the agent was still grading its own work. If it misunderstood what I wanted, it could build the wrong thing, write tests for the wrong thing, and then confidently tell me that everything passed.&lt;/p&gt;
&lt;p&gt;That’s why being able to open the running environment mattered. I could use it myself, drive the new UI end to end, and make sure it worked the way I wanted, not just the way the agent said it worked.&lt;/p&gt;
&lt;p&gt;Then there was the reviewing. When I wrote the code myself, I understood the change by the time it was ready for review. After all, I had made the decisions along the way. With an agent, the whole diff appeared at once. It might have passing tests and screenshots, but it was still unfamiliar code. And when several agents finished around the same time, I had a queue of complete changes to load into my head before I could merge any of them.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/slide-20-merge-queue-card.png&#34; alt=&#34;A queue of finished agent branches, each with passing tests and screenshots, waiting on one reviewer&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Having &lt;a href=&#34;https://blog.exe.dev/review-the-reviews&#34;&gt;other agents review the code&lt;/a&gt; worked surprisingly well. They occasionally caught real bugs, and it was cheap enough to run several reviews. But I couldn’t merge something just because the agents approved it. I still had to understand the change. I was still responsible for the code that got merged.&lt;/p&gt;
&lt;p&gt;And sometimes I understood it. The tests were green, the screenshots looked good, the UI did what I had asked for, even the schema looked good and the code was approved by all the review agents.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/1787847799-image.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;I threw it away anyway.&lt;/p&gt;
&lt;p&gt;Maybe nobody needed it. Maybe it introduced a second way to do something we already supported. Maybe a small convenience added complexity we would carry for years.&lt;/p&gt;
&lt;p&gt;The tools could tell me that the change worked. They couldn’t tell me whether it was worth adding to the system.&lt;/p&gt;
&lt;p&gt;Unshipping something is so much harder than shipping it. Hyrum’s Law kicks in: once enough people use a system, someone depends on every observable behavior, even behavior you never intended to be a contract. Removing something breaks users, scripts, and workflows you didn’t know existed.&lt;/p&gt;
&lt;p&gt;Shipping got easy. Deciding what to ship got important.&lt;/p&gt;
&lt;h2&gt;Not all agents write code&lt;/h2&gt;
&lt;p&gt;Everything so far has been about shipping code. But &lt;a href=&#34;https://blog.exe.dev/inventory&#34;&gt;some of the most useful agents we run&lt;/a&gt; don’t ship code at all.&lt;/p&gt;
&lt;p&gt;It’s worth pausing on what an agent actually is, because the word sounds heavier than it deserves. An agent is &lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;a model in a loop with tools&lt;/a&gt;. Send the model a message; if it asks for a tool call, run the tool and send the result back; repeat. That’s the whole thing.&lt;/p&gt;
&lt;p&gt;The model is what makes the loop capable. Give it bash on a real computer, and it can install what’s missing, adapt when your grep has different flags, and keep going until the job is done.&lt;/p&gt;
&lt;p&gt;The loop never changes. The tools decide what an agent can be. A development agent needs a full computer: shell, compilers, browsers, the freedom to install things. Hold those back and the agent is useless, and you’re back to approving every action.&lt;/p&gt;
&lt;p&gt;My starting point: give the agent whatever I’d give a developer. Good developer tools have turned out to be good agent tools. Whether the best agent tools end up being developer tools at all, time will tell.&lt;/p&gt;
&lt;p&gt;And the thing to fear isn’t any single tool. It’s combinations. Private data, untrusted content, external communication: any two are manageable. All three in one agent is how your secrets walk out the door. That’s what Simon Willison calls &lt;a href=&#34;https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/&#34;&gt;the lethal trifecta&lt;/a&gt;. So I don’t minimize tools blindly: I isolate the environment and I watch the combinations.&lt;/p&gt;
&lt;p&gt;Here’s the first example: investigation. When a customer reports a problem, I have a prompt I use, and it’s embarrassingly simple:&lt;/p&gt;
&lt;p&gt;“Customer reports: &amp;lt;their report, verbatim&amp;gt;. Please figure out what happened using the ClickHouse logs.”&lt;/p&gt;
&lt;p&gt;Verbatim matters. If I summarize the report, the agent inherits my interpretation - and my blind spots. Given the customer’s own words, it queries the logs, reads the relevant code, and reconstructs what actually happened.&lt;/p&gt;
&lt;p&gt;Then the decision is mine. Sometimes I ask for options and pick one. Sometimes the evidence says working-as-intended, and the fix is a doc or an email, not code. Either way I’m deciding from evidence, not guessing from a bug report.&lt;/p&gt;
&lt;p&gt;The second job: attack. Our red-team agent has one instruction: try to break into our systems.&lt;/p&gt;
&lt;p&gt;And it worked. It found open network paths we thought we had restricted, and showed us exactly how they were still reachable. We patched them before anyone outside ever noticed.&lt;/p&gt;
&lt;p&gt;That’s more useful than a list of theoretical vulnerabilities. It took an assumption we were relying on and tested it against the running system, and the assumption was wrong.&lt;/p&gt;
&lt;p&gt;The third job: watch. Deployments are scary, but not deploying is worse. We deploy in waves, and writing perfect rules for when to continue is basically impossible: production fails in weird ways.&lt;/p&gt;
&lt;p&gt;So &lt;a href=&#34;https://blog.exe.dev/athena-deploys-exe&#34;&gt;Athena&lt;/a&gt; babysits every deployment. It reads the diff, the metrics, and the logs, and watches the rollout. During one deployment it noticed a problem, investigated, and realized it was an infrastructure issue, not the new code. Instead of blindly halting everything, it continued deploying to the other machines.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/athena-rollout-card.png&#34; alt=&#34;A deployment rolling out in waves; Athena flags an infrastructure issue mid-rollout and keeps the wave going&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Could I do a better job? I’m not sure anymore. Athena is more diligent than I can be. It doesn’t get distracted, doesn’t get impatient, and never stops paying attention. It is tireless.&lt;/p&gt;
&lt;h2&gt;Engineer the system before the agent writes the code&lt;/h2&gt;
&lt;p&gt;An agent can now design and build an entire system almost instantly. The design might even be good. But if I simply accept it, do I know how it works? Where it breaks? Which corners it cut? Which tradeoffs I agreed to?&lt;/p&gt;
&lt;p&gt;At that point, I’ve inherited a legacy codebase that happens to be brand new. That’s vibe coding.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://blog.exe.dev/claude-is-not-a-compiler&#34;&gt;Agentic engineering&lt;/a&gt; is working with the agent on the system first: the architecture, interfaces, constraints, and tradeoffs. When the code arrives, I understand what I’m about to own.&lt;/p&gt;
&lt;p&gt;There is no one answer to agentic engineering. Everyone works differently; every model is good at different things. The key here is reps: do a lot, ask a lot, throw away a lot. You’ll learn what works for you.&lt;/p&gt;
&lt;p&gt;Everything we knew about running software teams is amplified now. Start with testing. When agents write and rewrite the implementation, unit tests that mirror the implementation just churn with it. Behavior, contract, and property tests matter so much more now: define the system’s invariants and pin down what must stay true while the code underneath changes freely.&lt;/p&gt;
&lt;p&gt;So much of the game is migrations now. Code changes are cheap, but systems carry state: data, running processes, users mid-flight. Getting from one design to the next without dropping any of that is the part that’s still hard. The job is risk management and migrations.&lt;/p&gt;
&lt;p&gt;The agent &lt;a href=&#34;https://blog.exe.dev/codebase-as-prompt&#34;&gt;copies what it finds in the codebase&lt;/a&gt;. Good patterns amplify. Bad patterns amplify faster. Engineering hygiene is more important than ever: every pattern you tolerate becomes the template for the next hundred changes.&lt;/p&gt;
&lt;p&gt;And it’s the &lt;a href=&#34;https://blog.exe.dev/devtools-must-be-open-source&#34;&gt;golden age of personalized tools&lt;/a&gt;. You don’t have to be a domain expert to write a new linter. So write a new linter. Enforce the pattern, encode the lesson, make the mistake impossible. The marginal cost of a bespoke tool has collapsed.&lt;/p&gt;
&lt;p&gt;Peer code review is dead. We don’t do code reviews at exe.dev: &lt;a href=&#34;https://blog.exe.dev/replace-your-ci&#34;&gt;we merge code we deem should be merged&lt;/a&gt;. The review that matters happens earlier: in the design discussion, the contracts, the validation. By the time the diff exists, the decisions are already made.&lt;/p&gt;
&lt;p&gt;Here’s a recent example. &lt;a href=&#34;https://blog.exe.dev/shelley&#34;&gt;Shelley&lt;/a&gt; is the coding agent we ship in exe.dev VMs. I wanted its tools to be asynchronous.&lt;/p&gt;
&lt;p&gt;The first design put the onus on the agent to decide which commands should run in the background. That introduced a ton of edge cases: large outputs, long-running tasks, blocked agents, and the agent having to predict all of this ahead of time.&lt;/p&gt;
&lt;p&gt;If I were vibe coding, I would have accepted that design and let the agent deal with those edge cases. Maybe it would have handled them. Maybe it wouldn’t have. I wouldn’t really know.&lt;/p&gt;
&lt;p&gt;Instead, we kept discussing the problem and found a design that removed most of the edge cases entirely. Every command follows the same path and automatically moves into the background after sixty seconds.&lt;/p&gt;
&lt;p&gt;I didn’t remember this example off the top of my head. I asked an agent to search across all of my agent conversations for a case where my questions had materially changed the architecture. It returned the original request, the first design, the objections I raised, how the design changed, the final commit, and links to the original sessions.&lt;/p&gt;
&lt;p&gt;This is why preserving every conversation mattered. The history wasn’t just an archive. I could query it to understand how I worked.&lt;/p&gt;
&lt;h2&gt;botd is dead; long live botd&lt;/h2&gt;
&lt;p&gt;There’s one more part of this story. &lt;code&gt;botd&lt;/code&gt; died this month. It crumbled under its own weight.&lt;/p&gt;
&lt;p&gt;That probably shouldn’t be surprising. &lt;code&gt;botd&lt;/code&gt; was entirely vibe coded. I didn’t read a single line of its code, nor did I really pay attention to how it was architected. And at its core was a genuinely hard problem: driving every model family through its own native harness (Claude Code, Codex, and the rest) while papering over their differences. That is exactly the kind of problem where architecture matters, and I was not paying attention to it.&lt;/p&gt;
&lt;p&gt;It helped me deliver an enormous amount of work, but it eventually became the exact thing I described earlier: a brand-new legacy codebase that I had inherited without understanding all of the decisions inside it. The architecture was exploratory, and some of the decisions buried in it made even modest changes mean redoing large parts of the system. And I wanted to build on top of Shelley so that I could control the harness better; botd was living on borrowed time. It just died before I could retire it.&lt;/p&gt;
&lt;p&gt;But here’s the twist: that search I described earlier was never sent to botd. All the history was in SQLite, so I pointed another agent at it and got the analysis anyway. The tool died; the data didn’t.&lt;/p&gt;
&lt;p&gt;When I started, my advantage was that the system lived in my head. Six months later, the honest answer is that I’ve lost some of that depth. I don’t have the same line-by-line familiarity with every system.&lt;/p&gt;
&lt;p&gt;But I can ask agents detailed questions and use them to dig into whatever I need to understand. Work no longer waits for me to finish one thing before starting another.&lt;/p&gt;
&lt;p&gt;I’ve shipped more in these six months than in any stretch of my career. I’ve also failed more: abandoned VMs, dead-end designs, a whole tool that collapsed. The failures were cheap, so I could afford a lot of them - that’s most of how I learned what works.&lt;/p&gt;
&lt;p&gt;It’s the same loop that taught me to code, moved up a level: write, run, fail, fix. I used to iterate on code. Now I iterate on prompts, designs, whole features. A rewrite that used to cost a week costs a conversation. And &lt;a href=&#34;https://x.com/davidcrawshaw/status/2022738438932566310&#34;&gt;understanding is iterative&lt;/a&gt; too: every conversation helps me understand and internalize the system more.&lt;/p&gt;
&lt;p&gt;I stopped writing code by hand. I didn’t stop engineering.&lt;/p&gt;
</content>
    <author>
      <name>Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>We Taught sqlc to Invalidate Our Caches</title>
    <link href="https://blog.exe.dev/we-taught-sqlc-to-invalidate-our-caches" />
    <id>https://blog.exe.dev/we-taught-sqlc-to-invalidate-our-caches</id>
    <updated>2026-08-20T22:28:00Z</updated>
    <summary>How exe&#39;s proxies stay fast and correct without anyone hand-writing invalidation logic.</summary>
    <content type="html">&lt;p&gt;People connecting to sites hosted on &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; are contacting a proxy server that routes the connection to the correct VM. Routing depends on details about the connection, such as the HTTP Host header or an SSH public key. It also depends on details of &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; internal network, such as where the VM is running and how to access it. These details are, naturally, stored in a database.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://Exe.dev&#34;&gt;exe.dev&lt;/a&gt; proxies run all over the world. We don’t want every incoming connection to have to check with a single centralized database; that would introduce unnecessary slowness. We also don’t want to replicate the entire database to every proxy; most of the information in the database is irrelevant to the proxy, and some of it is potentially sensitive, such as links to billing information.&lt;/p&gt;
&lt;p&gt;The natural approach is for the proxy to cache the information that it needs. The first time somebody uses a particular proxy to contact a particular VM, we do a slow query of the centralized database. After that, each subsequent connection is handled out of a local cache.&lt;/p&gt;
&lt;p&gt;Of course, information changes over time. People can change the sharing status of their VMs, VMs can move to different hosts, and in general the routing information that the proxy is using can change. So while using a cache is efficient, it means that we have to handle what is notoriously one of the two hard problems of computer systems: cache invalidation (the other hard problem is naming; also, off-by-one errors).&lt;/p&gt;
&lt;h2&gt;sqlc&lt;/h2&gt;
&lt;p&gt;Before we tackle cache invalidation, let’s back up and discuss database access.&lt;/p&gt;
&lt;p&gt;Our code is written in Go, and our database access uses the excellent &lt;a href=&#34;https://pkg.go.dev/github.com/sqlc-dev/sqlc&#34;&gt;sqlc&lt;/a&gt; tool. The sqlc tool is a code generator that parses SQL commands and generates type-safe functions to execute those commands. This brings the advantage of compile-time static type checking to the dynamically typed SQL language. The sqlc tool understands how to parse SQL statements for various databases. For every database operation, it generates a type-safe function that performs the operation. At exe, all of our database access goes through functions generated by sqlc.&lt;/p&gt;
&lt;h2&gt;Table and Row Information&lt;/h2&gt;
&lt;p&gt;Given that we are already using tooling for database access, it was a small extension to that tooling to support cache invalidation. We tweaked our copy of sqlc to emit additional code in each generated function.&lt;/p&gt;
&lt;p&gt;In a function that reads from the database, we record a mapping from a database table name to the field/value pairs used to select rows from the table. The mapping is stored in the Go context value, so that it accumulates across a set of database operations that share a context.&lt;/p&gt;
&lt;p&gt;In a function that writes to the database, we call a user-supplied function for each write operation, again passing a mapping from a database table name to the field/value pairs used to select rows from the table. We don’t record the changed fields, we only record the fields used to select the row (in SQL terms, this is the WHERE clause). We only call the function when the transaction is committed.&lt;/p&gt;
&lt;h2&gt;Cache Invalidation&lt;/h2&gt;
&lt;p&gt;When a proxy needs information that isn’t cached locally, it contacts the central database. During this operation it records the database tables and rows that are accessed. Because this is done via the sqlc generated code and the Go context value, there is no need for the code to know ahead of time what database information is relevant, and the recorded information is always accurate even as the program changes or the database is rearranged. We record the table and row information in a cache invalidation data structure.&lt;/p&gt;
&lt;p&gt;All database changes, wherever they originate, go through a single writer process to reach the database. That is the one we instrument via sqlc. The sqlc hooks check the cache invalidation data structure. If the write affects a table that some cache depends upon, we send a cache invalidation message to all proxies that accessed the data. The message includes the fields and values used to select the row.&lt;/p&gt;
&lt;p&gt;When the proxy receives the message, it knows the database table that was modified, and the field values used to select the row. That is enough information to clear the cache elements that may have been modified. We don’t attempt to be precise about modification. If some field changed for a particular VM, we simply discard all cached information for that VM. The proxy will refetch the data from the central database when and if it is needed.&lt;/p&gt;
&lt;p&gt;For example, a proxy may need information about the VM with ID 789. It will ask the centralized database for that information, which will send all relevant information about the VM, including the ID and owner and routing information. The database server will record that the proxy got information from the VM database table. Later something about that VM may change, perhaps because we are changing all information about VMs owned by the user baz. The writer process will see that the table changed, and send a notification to the proxy saying that a VM owned by baz changed. The proxy, which knows the ID and owner of all VM information it has cached, will discard from the cache all information about VMs owned by baz.&lt;/p&gt;
&lt;p&gt;This approach automatically detects the information that is cached, and automatically detects the cases where the cached information may be out of date. That is enough for reliable cache invalidation, and reliable VM routing.&lt;/p&gt;
</content>
    <author>
      <name>Ian Lance Taylor</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Have an Agent Babysit Your Deployments</title>
    <link href="https://blog.exe.dev/athena-deploys-exe" />
    <id>https://blog.exe.dev/athena-deploys-exe</id>
    <updated>2026-08-18T18:30:00Z</updated>
    <summary>The question is not: could a human do it better? The question is: in practice, will a human actually do it at all?</summary>
    <content type="html">&lt;p&gt;Deployments are scary. That’s the moment you break things.&lt;/p&gt;
&lt;p&gt;Not-deployments are even scarier. Waiting just makes the next deployment bigger.&lt;/p&gt;
&lt;p&gt;As the saying goes: “If it hurts, do it more.”&lt;/p&gt;
&lt;p&gt;The obvious, correct answer is CD. But then you’re off building canaries and waves and automated detection systems as gates. Canaries and waves are easy. Automated detection systems are hard. There are an indefinite number of things that can go wrong, and missing one of them takes you down. The asymmetry there is exactly the same asymmetry that makes deployments scary in the first place.&lt;/p&gt;
&lt;p&gt;The historical answer was: It’s a lot of engineering effort and a lot of pain. And so CD gets delayed, and humans babysit deployments, and deployments happen infrequently, and the cycle of inefficient misery and fear continues.&lt;/p&gt;
&lt;p&gt;This has exactly the right shape for an agent instead of code: Lots of rich data, a very long tail of possible states, relatively few runs (a handful a day, not 100qps).&lt;/p&gt;
&lt;p&gt;And we now have intelligence on tap. Let’s use it!&lt;/p&gt;
&lt;p&gt;At exe, Athena oversees our deployments. (All our bots have names, but that’s just so it’s easy to talk about them. &lt;a href=&#34;https://blog.exe.dev/botiquette&#34;&gt;They’re programs, not people&lt;/a&gt;.)&lt;/p&gt;
&lt;p&gt;Athena sits in a system called “exe-ops” which is our Deployment Command Center. We started with shell scripts, but then built a UI. Traditionally, you do a migration to something like Spinnaker. Instead, we’re building up from shell scripts into the exact shape we want.  Athena is part of that story.&lt;/p&gt;
&lt;p&gt;The bot has read access to git and metrics and logs. It decides at each stage: should we proceed? Which machines should be in the next wave? It can escalate to a human and it can pause a deployment—or  refuse to start one, if it deems it unwise. It communicates by sending us Slack messages.&lt;/p&gt;
&lt;p&gt;It’s great! It is diligent and thorough. It reads the diffs, analyzes the logs, checks for unforeseen issues, self-heals around weird problems, and reports on how to make future runs smoother.&lt;/p&gt;
&lt;p&gt;I could probably oversee deployments better than Athena. But the important question is not “in theory, &lt;em&gt;could&lt;/em&gt; I do a better job?” but “in reality, &lt;em&gt;will&lt;/em&gt; I do a better job?” We’re all busy. Athena does a much, much better job than I actually would.&lt;/p&gt;
&lt;p&gt;Athena lets me focus my attention elsewhere, until something happens that’s worth my intervention. And by deploying more often, those interventions are rarer and smaller.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>No Plan Survives Contact With the Enemy (Reality)</title>
    <link href="https://blog.exe.dev/planning" />
    <id>https://blog.exe.dev/planning</id>
    <updated>2026-08-14T22:00:00Z</updated>
    <summary>People who use coding agents are either planner or iterators (or somewhere on that spectrum). The two sides are closer than you think.</summary>
    <content type="html">&lt;p&gt;If you’ve ever presented the design of a product after the fact, you know the most interesting bit is the &lt;strong&gt;surprises&lt;/strong&gt;. What broke at scale? Where did you change course? What did the customers do that you didn’t expect? What were the interesting metrics? These are impossible to predict in advance. They’re also the most important parts—the punch lines.&lt;/p&gt;
&lt;p&gt;When we talk to folks about how they use coding agents they usually fall near one end of a spectrum: &lt;strong&gt;planners&lt;/strong&gt;, who work on a spec or design with an agent, and &lt;strong&gt;iterators&lt;/strong&gt;, who write a short prompt, and iterate on (or throw out) the results. Of course, this is all new, and none of us knows what we’re doing yet. (This is the time to let a thousand flowers bloom. Build your own &lt;a href=&#34;https://blog.exe.dev/inventory&#34;&gt;software factory&lt;/a&gt;.)&lt;/p&gt;
&lt;p&gt;But the debate on planning vs iteration is not new. (And neither side is right, though you should consider about what works for your team, and why). We’ve read clear PRDs or slides that have set the direction for a product or project. We’ve been in meetings where the prototype carried the day after weeks of failed paper designs. And everything in between.&lt;/p&gt;
&lt;p&gt;If your most precious commodity is your attention, ask your agents for the design &lt;em&gt;after&lt;/em&gt; they’ve built the thing. Ask it for the surprising things. The sticky bits. The workarounds. The contentious topics in &lt;a href=&#34;https://blog.exe.dev/review-the-reviews&#34;&gt;review&lt;/a&gt;. The traditional &lt;a href=&#34;https://en.wikiquote.org/wiki/Frank_Westheimer&#34;&gt;funny quote here is from Frank Westheimer&lt;/a&gt;, who said “Why spend a day in the library when you can learn the same thing by working in the laboratory for a month?” If it’s the coding agent—and not you—in the lab, however, this is turned upside down: let the agent spend some extra cycles in the lab, and get one layer deeper on the design.&lt;/p&gt;
&lt;p&gt;The planners and iterators are closer than they think: a plan that’s been prototyped is a better plan.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger and Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>OAuth for Agents</title>
    <link href="https://blog.exe.dev/oauth-for-agents" />
    <id>https://blog.exe.dev/oauth-for-agents</id>
    <updated>2026-08-11T13:00:00Z</updated>
    <summary>Agents shouldn&#39;t hold long-lived secrets. Give them an identity instead—and short-lived access when they need it.</summary>
    <content type="html">&lt;p&gt;Agents are unusually capable credential-handling tools. They read logs, execute commands, inspect files, call external services, and frequently operate on inputs that weren’t written by the person who deployed them.&lt;/p&gt;
&lt;p&gt;Giving an agent a long-lived secret means trusting not only the agent itself, but every tool it invokes, every file it reads, and every instruction it encounters, magnified by autonomous decision making.&lt;/p&gt;
&lt;p&gt;At exe, we believe agents should be able to access everything they need. That said, we do our best to avoid giving them persistent credentials that could leak.&lt;/p&gt;
&lt;p&gt;The safer model is to give the agent an identity and let it obtain narrowly scoped, short-lived access when it needs it. We’ve already built quite a few things around this idea, including our HTTPS proxy integration and our LLM integration, and recently we added support for Workload Identity Federation, or WIF.&lt;/p&gt;
&lt;p&gt;So what is WIF, and why is it a big deal?&lt;/p&gt;
&lt;p&gt;Years ago, back when I was working on Kubernetes, one of the most popular workflows users had was giving workloads running in k8s access to some cloud resource, say BigQuery.&lt;/p&gt;
&lt;p&gt;The typical solution up until that point was to create a service account, download its secret JSON file—which let you act as that service account—put it in a Secret in the k8s API, mount it into your pod, and then configure the cloud APIs to use it.&lt;/p&gt;
&lt;p&gt;It was a fairly suboptimal user experience. The secret had to be long-lived, could be leaked, needed to be rotated periodically, and there was really no way to know who or what was using it.&lt;/p&gt;
&lt;p&gt;Sounds familiar!&lt;/p&gt;
&lt;p&gt;Then the great security engineers working on Kubernetes realized that, by adding a few features to GCP and Kubernetes, they could use the Kubernetes API server as a trust boundary by having it act as an identity provider.&lt;/p&gt;
&lt;p&gt;In some ways, it already was one: the secrets were stored there, it already had a concept of service accounts, and it knew which workload was running as which identity.&lt;/p&gt;
&lt;p&gt;It worked by letting pods ask the k8s API server for a signed token (or JWT), which could then be presented to GCP to impersonate a service account. GCP would confirm that the k8s API server had signed it and that the cluster was within the configured trust boundary.&lt;/p&gt;
&lt;p&gt;If everything was configured correctly, your Kubernetes pods could now magically act as a GCP service account without ever being given a long-lived GCP credential. As a bonus, you could know exactly which pod was accessing which resources.&lt;/p&gt;
&lt;p&gt;Under the hood, this uses a lesser-known OAuth 2.0 flow called &lt;em&gt;token exchange&lt;/em&gt;. One system issues a cryptographically signed token asserting who you are, and another system decides whether it trusts that issuer and is willing to exchange that token for one of its own.&lt;/p&gt;
&lt;p&gt;The method quickly spread, and all the major clouds shipped some version of it. Things like GitHub Actions adopted it too, letting you use GitHub’s identity to access cloud resources instead of storing long-lived cloud credentials.&lt;/p&gt;
&lt;p&gt;The new exe WIF integration follows suite and allows an agent (or workload) running on exe to use its identity to access resources on any cloud, or really anywhere, without needing a long-lived credential sitting around inside the VM.&lt;/p&gt;
&lt;p&gt;It is the same basic idea Kubernetes arrived at years ago: give the workload an identity, establish trust between systems, and mint short-lived access when it is actually needed instead of copying secrets everywhere.&lt;/p&gt;
&lt;p&gt;To use it in exe, go to the integrations page and create a new Identity Federation integration. You can then attach it to tags or individual VMs.&lt;/p&gt;
&lt;p&gt;You’ll need to configure the resource provider (GCP, AWS, etc) to consume the credentials. We have some guides for &lt;a href=&#34;https://exe.dev/docs/integrations-aws-wif&#34;&gt;AWS&lt;/a&gt; and &lt;a href=&#34;https://exe.dev/docs/integrations-gcp-wif&#34;&gt;GCP&lt;/a&gt; already and more are coming soon.&lt;/p&gt;
&lt;p&gt;We would love to hear which services you would use this with and how we could improve the experience.&lt;/p&gt;
&lt;h2&gt;Bonus - sequence diagram&lt;/h2&gt;
&lt;pre class=&#34;mermaid&#34;&gt;sequenceDiagram
    autonumber

    box Inside the exe VM
        actor Agent as Agent or workload
        participant Auth as Google auth library
    end

    box exe.dev
        participant Integration as Attached WIF integration
        participant Issuer as exe.dev OIDC issuer
    end

    box Google Cloud
        participant STS as Google STS
        participant IAM as IAM Credentials API
        participant BigQuery as BigQuery
    end

    Note over Integration,BigQuery: One-time setup&amp;lt;br/&amp;gt;The integration is attached to this VM&amp;lt;br/&amp;gt;Google trusts the exe.dev OIDC issuer&amp;lt;br/&amp;gt;The exe identity may impersonate the service account

    Agent-&amp;gt;&amp;gt;Auth: Make a BigQuery request

    Note over Auth: Google auth loads the external account configuration&amp;lt;br/&amp;gt;and discovers the exe token endpoint

    Auth-&amp;gt;&amp;gt;Integration: Request an exe identity token

    Note over Integration,Issuer: Request crosses from the VM&amp;lt;br/&amp;gt;into exe.dev

    Integration-&amp;gt;&amp;gt;Integration: Verify the VM is allowed&amp;lt;br/&amp;gt;to use this integration
    Integration--&amp;gt;&amp;gt;Auth: Short-lived exe.dev OIDC token

    Note over Auth,STS: The VM sends the exe identity token&amp;lt;br/&amp;gt;directly to Google Cloud

    Auth-&amp;gt;&amp;gt;STS: Exchange exe.dev OIDC token&amp;lt;br/&amp;gt;for a Google federated token

    opt Google does not have the signing keys cached
        STS-&amp;gt;&amp;gt;Issuer: Fetch OIDC metadata and signing keys
        Issuer--&amp;gt;&amp;gt;STS: Issuer metadata and signing keys
    end

    STS-&amp;gt;&amp;gt;STS: Verify signature, issuer,&amp;lt;br/&amp;gt;audience, expiry, and subject
    STS--&amp;gt;&amp;gt;Auth: Short-lived federated token

    Auth-&amp;gt;&amp;gt;IAM: Request an access token for&amp;lt;br/&amp;gt;the configured service account
    IAM-&amp;gt;&amp;gt;IAM: Verify the exe identity may&amp;lt;br/&amp;gt;impersonate the service account
    IAM--&amp;gt;&amp;gt;Auth: Short-lived service account access token

    Auth-&amp;gt;&amp;gt;BigQuery: Call BigQuery with&amp;lt;br/&amp;gt;the service account access token
    BigQuery--&amp;gt;&amp;gt;Auth: Query response

    Auth--&amp;gt;&amp;gt;Agent: Return result
&lt;/pre&gt;</content>
    <author>
      <name>Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>The End of No Code</title>
    <link href="https://blog.exe.dev/the-end-of-no-code" />
    <id>https://blog.exe.dev/the-end-of-no-code</id>
    <updated>2026-08-06T15:00:00Z</updated>
    <summary>Writing custom software used to be expensive. Coding agents changed the math.</summary>
    <content type="html">&lt;p&gt;You may have heard the news: Bending Spoons acquired Airtable for $1.28 billion. Rome didn’t fall in a day, but this is as good a point as any to mark the moment No Code platforms jumped the shark. Full disclosure, I worked at Airtable for many years, love the product, and love the people I worked with there even more. It’s the technology, namely the unreasonable effectiveness of &lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;LLM loops with tool use&lt;/a&gt;, that’s changed.&lt;/p&gt;
&lt;p&gt;Software at work is not valuable in and of itself. It’s built to serve some purpose. Mostly it’s used to keep track of something (schedules, parts, orders, people, you name it). Spreadsheets are the universal software here–and I love me a spreadsheet. But spreadsheets have a ceiling when it comes to sharing, programming, permissions, automations, and so on. Once you leave a spreadsheet, you upgrade to a database and some software on top of it: that’s what low or no code platforms like Airtable are. At their best, the person who brings Airtable to their team isn’t bringing Airtable: they’re bringing much-needed organization and process, and Airtable is merely the means.&lt;/p&gt;
&lt;p&gt;One of the things that Airtable got right was their experience of creating the tables themselves. You just added a column (like in Excel), and chose a data type (string, number, date, and so on), and, voila, you’ve created a table. I used to joke that Airtable should show up to SIGMOD (the big database conference) and present a paper on the efficacy of &lt;strong&gt;not&lt;/strong&gt; having &lt;code&gt;ALTER TABLE widgets ADD COLUMN (color string)&lt;/code&gt; as the way people use your database. &lt;a href=&#34;https://en.wikipedia.org/wiki/Fred_Brooks&#34;&gt;Fred Brooks&lt;/a&gt; wrote: “Show me your flowcharts and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won’t usually need your flowcharts; they’ll be obvious.” Airtable understood this at its core: if the user can specify the business model, building the automations and features on top of it becomes possible. (This is nothing new! &lt;a href=&#34;https://en.wikipedia.org/wiki/FileMaker&#34;&gt;FileMaker&lt;/a&gt; launched in 1985; it was my introduction to databases when I helped run a conference for ~1,600 high school students. It turns out that a little bit of extra credit, some freshmen, and 3 AppleTalk-connected computers could handle the mailed-in registration forms!) &lt;/p&gt;
&lt;p&gt;Once upon a time (the 90s!), IT teams at companies existed to build software for said companies. Much software was bespoke. We can use Salesforce’s 2000 “Software is Dead” campaign as the mile marker for when SaaS started taking over. IT departments became all about procurement. And procurement means saying NO. Low code and No Code platforms (and Microsoft SharePoint and Excel and Google Sheets) picked up the slack. When you can’t buy the software, you make do with what you can get access to, and you smuggle in some Airtable, increase revenues/efficiency/trust/whatever, and nobody can get rid of it for bureaucratic reasons because it’s now load-bearing.&lt;/p&gt;
&lt;p&gt;AWS launched EC2 in 2006. You could rent a VM. Getting it on the internet (so that you could share a thing with your co-workers) required learning about EC2 VPCs, IAM permissions, EBS, RDS, static IPs, DNS, and a handful of other Three Letter Acronyms (TLAs). Even within software companies, IT gatekept EC2. When I was at Google in 2007, the tool to search the company’s code base ran on a spare desktop under Jeff Dean’s desk. Getting a machine in Google’s datacenter to serve this (to me, critical) piece of infrastructure was too much of a hassle. (There were, at the time, funny “Is it web scale?” videos; e.g., &lt;a href=&#34;https://www.youtube.com/watch?v=b2F-DItXtZs&#34;&gt;https://www.youtube.com/watch?v=b2F-DItXtZs&lt;/a&gt;, amongst others.)&lt;/p&gt;
&lt;p&gt;Fast forward to 2026. LLMs are king. The SaaSpocalypse is under way, and happening like bankruptcy–gradually first, then all at once. What is the right way to build and deploy business tools? What is the right platform? Can non-software-engineers be trusted to do it?&lt;/p&gt;
&lt;p&gt;The right answer (it’s my turn to be wrong on the internet today, baby) is Linux. Yes, &lt;a href=&#34;https://boringtechnology.club&#34;&gt;choose boring technology&lt;/a&gt;, and just use Linux. You can choose one of many stacks on top of Linux. Honestly, if you chose LAMP (Linux, Apache HTTPd, MySQL, PHP) you would be fine. My current preference is (sqlite, Go, Typescript, maybe Vue). If memory weren’t getting expensive, there’d be nothing wrong with (PostgreSQL, Node, TypeScript) but the memory crunch is real, and the advantages of using a single language for frontend and backend have disappeared since you’re not writing the code anyway.&lt;/p&gt;
&lt;p&gt;Yes, that entire stack is Open Source. Yes, if you build on that stack, and you need to migrate to AWS or GCP or Render or Azure or Oracle Cloud Infrastructure or Railway or Hetzner or a miniPC, you will be able to rsync the data and code over, and you’ll be all set. The platform-level lock-in is weak compared to low code platforms. (That said, an agent will port your low code setup to Linux with a few prompts.)&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://Exe.dev&#34;&gt;Exe.dev&lt;/a&gt; sells this very stack. Your subscription lets you create Linux VMs. They’re on the internet in the way that matters: you can send links to your friends, and the links will work. They are secure by default, and you can make sites public using our auth system or your very own. They’re fast. They’re great for coding agents. The way to build your custom software is to build it right there in prod with the coding agent. Iterate until you get something usable. Iterate some more with feedback from your co-workers. Let your co-workers iterate on it too; let them sand down the edges. If you give the coding agent the data model for your business and the workflows, and a hint about the stack maybe, it will do ok. If your project is in the 1 percent of projects that need to graduate to “Business Critical Very Important Stuff,” sure, start a second VM and a dev environment, or maybe even graduate to the confusing trappings of modern software development (git). An LLM running on a Linux machine is the ultimate in “low floor, high ceiling”: just get started, and you’ll perhaps be able to leave your spreadsheet in the dust.&lt;/p&gt;
&lt;p&gt;Moving on to some relevant FAQs.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Is my data secure?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Yes. Our defaults are secure. The mechanics are very similar to a Google Sheet: you can share a VM’s web port with just your team or individual people or the world.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;I have a spreadsheet or a low code solution already; how do I port it?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;If you’re comfortable doing so, start the VM, visit the agent (ours is called Shelley and it’s pre-installed by default), and give it an API key to your existing solution or upload your spreadsheet. Tell it to port it over into a web application on this machine. It will. Today, use Sol or Opus as the model. Tomorrow, ask us on Discord; the answer changes kinda frequently.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How do I do schedules? Automations?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Linux is a rich platform. You can ask the agent to run something on a timer, and it will. (It will usually choose systemd, but if you have a preference for cron, nudge it in that direction, and if you don’t know what either of those are, that’s ok!)&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How do I build agents or bots?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;The same way: ask the agent to write an “agentic loop using the &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; LLM integration” with tools to do this and that. So, perhaps it reads Slack threads in a certain channel and comments on that. The agent will one-shot it.&lt;/p&gt;
&lt;p&gt;One of the best things about the &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; platform is our “Integrations” system. Hooking up your bot to Slack has never been easier.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Is Vibe Coding good enough?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;In my experience, yes. The usual thing is to measure Risk and Reward. Every spreadsheet formula is fragile and untested and so on; and yet, spreadsheets work! Same applies here.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Shouldn’t I use the Flue agent framework? Or maybe some framework from Langchain? Can I really just yolo it?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Use whatever frameworks you like, but, ultimately, the agents are fine at choosing their own, or just doing it the boring way. There are millions of conflicting best practices the world over, “P &amp;amp; L FINAL FY2025 FINAL VERSION 3” is still the median solution, and you should figure out your workflow needs first. Have the agent set up a cron job to back up the database somewhere, too.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How does your pricing work?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;The basic plan for $20/month gives you up to 50 VMs, but they are limited to 2 CPUs and 8GB of RAM. This is enough for quite a few small apps targeted toward your team. If you need more resources, you can upgrade or ask us; we are happy to get you machines as big as you need. Building your app may take more LLM tokens than we provide as part of your subscription. You can hook up a ChatGPT subscription, use other coding agents, or other model providers, or we’re happy to give you the LLM at API token costs through us.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;What if the app is slow? How do I test it?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;I’ve found that the agents are surprisingly good at both testing their end result and fixing performance issues. They use the same tools I use: profilers and so on. Shelley’s secret weapon is a good browser tool that it’s capable of using, profilers, screenshots, screencasts, and all.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>A Non-Exhaustive Inventory of exe&#39;s Software Factory</title>
    <link href="https://blog.exe.dev/inventory" />
    <id>https://blog.exe.dev/inventory</id>
    <updated>2026-08-06T13:00:00Z</updated>
    <summary>A quick tour of the internal tools and agents that keep exe running.</summary>
    <content type="html">&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;An agent that looks for security issues systematically.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Fable refuses to help out, so we systematically look for security issues, with a bias toward recent changes.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;An agent that investigates alerts.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Sisyphus keeps track of our alerts. We have ones that page us and ones that merely make noise in Slack. Either way, Sisyphus looks through our logs and metrics and source code, as well as analyzing its own previous investigations, to tease out what’s going on. It gives a great head start when investigating an issue (or just a flaky alert!).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;An agent that investigates logs.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Every day, I get an email with interesting trends in our logs.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Bots to fix flaky and slow tests.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A bot is continuously analyzing flaky or slow tests in our CI and suggesting changes.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;A status page.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://status.exe.dev&#34;&gt;status.exe.dev&lt;/a&gt; isn’t hosted on exe.dev. We built it ourselves, though.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;A system to page our phones (using the excellent and simple PushOver)&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;When the aforementioned alerts fire, our phones beep very loudly. Traditionally you use PagerDuty for this, but PagerDuty’s durable asset is the entitlement for “Emergency Alerts” from Apple. Turns out PushOver has this as well, and a lovely API.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;An agent that supervises deploys and rollouts.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Athena helps do rollouts. Infrastructure deploys are not instantaneous, and even the most patient operators stop paying attention. It checks metrics and logs (and has looked at the source code for what changed in this deploy).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;A blog CMS, with comments, collaborative text editing, embargoes, the whole nine yards&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;If you’re reading this on blog.exe.dev, this ain’t Wordpress. Our blog started out as Markdown files in git, but now there’s a full-featured CMS, with collaborative editing, revision history, comments, embargoes, and a content calendar. A built-in agent (really, Shelley running on the same VM) can import a blog post from whatever you paste in.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;UI tests described as textual paragraphs that lazily materialize into browser instructions but self-heal&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Who are we kidding? We’re not maintaining Playwright tests by hand anymore. Shelley’s UI tests are increasingly a paragraph of text asking for some behavior. There’s a cache file (checked into git) that makes the test cheap and fast. When it fails, the CI system “heals” it with an LLM, and either fails or checks in the new fixed test. Yes, the build queue modifies the commit on its way through if necessary. More on this in a future post.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Intrepid reporter bots that report on git commits, our help threads, and so on&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Every day, we get summaries in Slack about what’s happened in the past day, across git commits and such.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Please note: if you’re writing bots that read untrusted data, understand the &lt;a href=&#34;https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/&#34;&gt;Lethal Trifecta&lt;/a&gt;: private data, untrusted content, and external communication. We happen to think that &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VMs are a great place to isolate these bots, but we also make sure that the tools available to these agentic loops (an agent is just 11 lines of code: &lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;https://sketch.dev/blog/agent-loop&lt;/a&gt;) are limited in what they can do.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Simpler GitHub Integration URLs, Plus Read-Only Access</title>
    <link href="https://blog.exe.dev/github-integration-improvements" />
    <id>https://blog.exe.dev/github-integration-improvements</id>
    <updated>2026-08-05T22:17:00Z</updated>
    <summary>Reach any authorized repo at one URL. And mark an integration read-only when your agent should look but not touch.</summary>
    <content type="html">&lt;p&gt;exe.dev integrations let you keep secrets outside of your VM; a proxy injects the secrets. Sometimes this is as simple as adding an HTTP header, and sometimes the integration is bespoke.&lt;/p&gt;
&lt;p&gt;We recently gave our GitHub integration two new features:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;One URL for any repo: Any repo that a VM has access to (including team integrations) can be accessed at &lt;code&gt;https://github.int.exe.xyz/OWNER/REPO&lt;/code&gt;. We automatically pick the appropriate integration, saving you the trouble of remembering the integration name as well. We take compatibility seriously, so your old git remotes will work just fine.&lt;/li&gt;
&lt;li&gt;Read-only integrations: You can mark a GitHub integration as read-only, both for git operations (fetch, not push) and GitHub API operations.&lt;/li&gt;
&lt;/ul&gt;
</content>
    <author>
      <name>Maisem Ali and Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Introducing Auto-Purchasing for Shelley Tokens</title>
    <link href="https://blog.exe.dev/new-feature-auto-purchase-shelley-tokens" />
    <id>https://blog.exe.dev/new-feature-auto-purchase-shelley-tokens</id>
    <updated>2026-08-05T19:34:00Z</updated>
    <summary>Now you don&#39;t need to manually purchase more credits when you exhaust your token stores.</summary>
    <content type="html">&lt;p&gt;&lt;br /&gt;
We’re happy to announce that you can now enable auto-purchasing of Shelley Tokens. Previously, you had to manually purchase more credits every time you exhausted your token store. With auto-purchasing, you no longer have to take time out of your day to click through the UI.&lt;/p&gt;
&lt;p&gt;We also added safeguards to this feature to avoid runaway spend. There are three options you can configure:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A floor amount that triggers a purchase.&lt;/li&gt;
&lt;li&gt;The number of tokens you wish to purchase each time.&lt;/li&gt;
&lt;li&gt;A monthly spending cap.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;You can access this feature via the SSH lobby:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;  billing auto-purchase status
  billing auto-purchase
  billing auto-purchase --floor=10 --amount=25 --cap=200 --yes
  billing auto-purchase disable
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Or from the newly redesigned Shelley page in the dashboard:&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/CleanShot-2026-08-04-at-16.02.08-2x.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;For our friends on Team plans, we are still working on a solution for shared tokens and payment methods. In the meantime, we’ve also enabled auto-purchasing for teams, but remember, it will use your own payment method.&lt;/p&gt;
&lt;p&gt;Go build something!&lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Botiquette</title>
    <link href="https://blog.exe.dev/botiquette" />
    <id>https://blog.exe.dev/botiquette</id>
    <updated>2026-08-05T15:13:00Z</updated>
    <summary>We have a lot of bots doing work at exe. Here&#39;s how they should behave.</summary>
    <content type="html">&lt;p&gt;There are lots of bots floating around exe, helping us organize and monitor and maintain our world. (Agents and bots and any LLM output are all synonyms for this post.) We’ve organically developed some etiquette around bots that work well for us.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Bots do not post to human spaces. Attention is precious, and bots are (currently?) incapable of gauging the cost of their posts.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;There is no expectation that other humans will read human posts to bot spaces. Or even bot posts to bot spaces.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Humans write their own words.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If a human pastes bot output into a post, that output is clearly marked as such, typically in block quotes or a code block.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Bot posts always include where the bot is running and where its source code is.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Bots have names, because it makes it easier to talk about them, but they are computer programs. Their pronouns are always “it/its”.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Ghostty in the Machine: The Saga of exe-scroll</title>
    <link href="https://blog.exe.dev/exe-scroll" />
    <id>https://blog.exe.dev/exe-scroll</id>
    <updated>2026-08-04T17:00:00Z</updated>
    <summary>Two ghostty instances stand between you and your shell. How exe-scroll keeps remote terminal sessions alive, plus a tour of the prior art: mosh, tmux, dtach, and web terminals.</summary>
    <content type="html">&lt;img src=&#34;/assets/exe-scroll.svg&#34; alt=&#34;Architecture diagram of exe-scroll: a browser running a ghostty wasm terminal talks over an HTTPS WebSocket (via exeprox) to an exe-scroll attach client on the user&#39;s VM. The attach client exchanges input/output/resize frames over a unix socket (session.sock) with the exe-scroll session process, which owns the pty, runs the shell, and embeds a ghostty-vt emulator so it can replay screen and scrollback on attach. SSH clients attach through the same socket.&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
&lt;p&gt;When you use the mobile or web-based terminals on exe, there are two &lt;a href=&#34;https://ghostty.org&#34;&gt;ghostty&lt;/a&gt; instances involved. One is rendering the terminal in the app or the browser (via a ghostty build compiled to WebAssembly). The other is on the VM in the session manager, providing scrollback on reconnection. (Scrollback is more complicated than just replaying all the received bytes, so it helps to re-use Ghostty&#39;s excellent terminal support.)&lt;/p&gt;
&lt;p&gt;Whoa! What? Why!?!&lt;/p&gt;
&lt;img src=&#34;/assets/scrollback.gif&#34; alt=&#34;Screen recording of the exe.dev iOS app terminal: flicking through scrollback of a numbered-lines listing, smoothly scrolling up through earlier output.&#34; style=&#34;max-width: 320px; width: 100%; height: auto; display: block; margin: 0 auto;&#34;&gt;
&lt;p&gt;To make remote terminals work well, you need 4 ingredients:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Network roaming:&lt;/strong&gt; when the client switches networks, the terminal should reconnect automatically and seamlessly.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Session management:&lt;/strong&gt; you need to be able to resume a session that you started on your laptop on your phone and vice-versa.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Scrollback:&lt;/strong&gt; scrolling up should work.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Modern terminal support:&lt;/strong&gt; colors and so on.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;On exe.dev, a login shell is one to one with an &lt;a href=&#34;https://github.com/boldsoftware/exe.dev/tree/main/exe-scroll&#34;&gt;&amp;quot;exe-scroll&amp;quot;&lt;/a&gt; session manager process on your VM. We can re-connect to this session by running an &amp;quot;exe-scroll&amp;quot; client (identified by a unix domain socket). We expose this over HTTPS to our clients (whether on the web or a mobile device), and you can connect to those sessions over SSH as well if that&#39;s your jam. Clients survive network roaming by retrying when the websocket disconnects. Session management is provided by having multiple exe-scroll processes, each with its own name. Scrollback is provided by that ghostty inside exe-scroll: when you re-connect, we replay the scrollback into your terminal. Modern terminal support is provided by the client, which, in the case of iOS and &lt;code&gt;&amp;lt;vm-name&amp;gt;.xterm.exe.xyz&lt;/code&gt; is also Ghostty.&lt;/p&gt;
&lt;p&gt;There has been much prior art on this. &lt;a href=&#34;https://mosh.org/&#34;&gt;Mosh&lt;/a&gt; establishes a connection secret over SSH and then the server (which stays put) and the client (which can move around) talk UDP to each other. Its &amp;quot;State Synchronization Protocol&amp;quot; synchronizes the state of the terminal between client and server. &lt;a href=&#34;https://eternalterminal.dev/&#34;&gt;Eternal terminal&lt;/a&gt; is similar to mosh. It requires running an &lt;code&gt;et&lt;/code&gt; server (typically port 2022), uses TCP, establishes a secret over SSH, supports native scrollback, the tmux control protocol, and ssh agent forwarding. Terminal multiplexers like &lt;code&gt;screen&lt;/code&gt;, &lt;a href=&#34;https://github.com/tmux/tmux/wiki&#34;&gt;&lt;code&gt;tmux&lt;/code&gt;&lt;/a&gt;, and &lt;a href=&#34;https://zellij.dev&#34;&gt;&lt;code&gt;zellij&lt;/code&gt;&lt;/a&gt; manage multiple ptys, and you can re-connect with them remotely. The drawback with terminal multiplexers is that you have to remember to invoke them (or panic install &lt;a href=&#34;https://github.com/nelhage/reptyr&#34;&gt;reptyr&lt;/a&gt; later) and using them has a learning curve. Tools like &lt;code&gt;dtach&lt;/code&gt;, &lt;a href=&#34;https://github.com/mobydeck/atch&#34;&gt;&lt;code&gt;atch&lt;/code&gt;&lt;/a&gt;, &lt;code&gt;zmx&lt;/code&gt;, and &lt;a href=&#34;https://github.com/martanne/abduco&#34;&gt;&lt;code&gt;abduco&lt;/code&gt;&lt;/a&gt; all skip the &amp;quot;window management&amp;quot; part of &lt;code&gt;screen&lt;/code&gt;/&lt;code&gt;tmux&lt;/code&gt;, but just handle attaching and detaching sessions. &lt;a href=&#34;https://owenou.com/upterm/&#34;&gt;upterm&lt;/a&gt; and tmate let you run a command on one terminal and access it from another. They do this with a relay server. If you don&#39;t trust the public relay servers, you need to run your own. &lt;a href=&#34;https://github.com/tmate-io/tmate/issues/322#issuecomment-3083138790&#34;&gt;tmate has shut down&lt;/a&gt; but I&#39;ve used it to &lt;a href=&#34;https://philz.dev/blog/ci-debugging/&#34;&gt;log into GitHub action runners&lt;/a&gt; in a pinch. You can also use a different network stack: if you use &lt;a href=&#34;https://tailscale.com&#34;&gt;Tailscale&lt;/a&gt;, your SSH session won’t die when you roam networks, because Tailscale is an overlay.  &lt;code&gt;autossh&lt;/code&gt; is essentially a &lt;code&gt;while true&lt;/code&gt; loop that reconnects SSH; you can pair that sort of thing with &lt;code&gt;dtach&lt;/code&gt; or &lt;code&gt;tmux&lt;/code&gt;. Many web-based terminals are available. &lt;a href=&#34;https://github.com/yudai/gotty&#34;&gt;gotty&lt;/a&gt; or &lt;a href=&#34;https://github.com/sorenisanerd/gotty&#34;&gt;gotty&lt;/a&gt; (yes, there are two with the same name) work. &lt;a href=&#34;https://tsl0922.github.io/ttyd/&#34;&gt;ttyd&lt;/a&gt; is another. To run these, you need secure HTTPS access to your host. A standard for HTTP-based terminal streams would be a boon to our industry, but right now it’s ad-hoc/unique protocols all the way down (e.g., &lt;a href=&#34;https://kubernetes.io/blog/2024/08/20/websockets-transition/&#34;&gt;here’s k8s&lt;/a&gt;).&lt;/p&gt;
&lt;p&gt;It seems ridiculous to build something new with so much prior art. We are much indebted to the prior art, especially &lt;code&gt;dtach&lt;/code&gt; and &lt;code&gt;zmx&lt;/code&gt;.  And yet &lt;code&gt;exe-scroll&lt;/code&gt; fills a particular exe.dev-shaped niche for our users: it manages only a single session with scrollback and nothing else. It can be paired with &lt;a href=&#34;https://github.com/boldsoftware/exe.dev/tree/main/exe-ssh&#34;&gt;exe-ssh&lt;/a&gt; (run it with &lt;code&gt;uvx --from &#39;exe-ssh @ git&#43;https://github.com/boldsoftware/exe.dev.git#subdirectory=exe-ssh&#39; exe-ssh vm-name&lt;/code&gt;) to have a connection to an exe.dev VM that survives network roaming. If you’re on an older &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VM, you may need to &lt;code&gt;ssh exe.dev exe-scroll install vm-name&lt;/code&gt;  or &lt;a href=&#34;https://github.com/boldsoftware/exe.dev/releases/latest/download/exe-scroll-linux-amd64&#34;&gt;download the binary&lt;/a&gt; directly. Give it a whirl!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Devtools must be open source</title>
    <link href="https://blog.exe.dev/devtools-must-be-open-source" />
    <id>https://blog.exe.dev/devtools-must-be-open-source</id>
    <updated>2026-08-02T00:00:00Z</updated>
    <summary>The age of personalized software is here.</summary>
    <content type="html">&lt;p&gt;Five years ago, most software engineers I spoke to had no programs they had written for themselves. (I was asking this question a lot as part of trying to understand how Tailscale could fit into engineers’ lives.) All day, every day, engineers use programs written by others to write programs for others. Many of us customized the programs we used, through config files or plugins or extensions, and many of us used the programs we wrote for others, as users. It was always an unusual treat to ask someone what they had written for themselves and learn about the bespoke software behind their blog, or their home automation, or their homelab, instead of an off-the-shelf, almost-the-right-size static site generator or Zigbee appliance.&lt;/p&gt;
&lt;p&gt;This state of things made a lot of sense to me. Over the years I have written plenty of software for myself, and the return on doing so was always questionable. I could only write so much in a day. There were always more important things to do (Something Was Wrong At Work), and coming back to a project after a year to do maintenance on it was always extraordinarily painful. There were plenty of years in my career where I had thrown out all my custom software and used the most bog-standard environments I could to produce code. In my early years as an engineer at Google I did not even own a personal computer.&lt;/p&gt;
&lt;p&gt;That was then. Things are different now.&lt;/p&gt;
&lt;h2&gt;How to Personalize Software&lt;/h2&gt;
&lt;p&gt;It is astonishingly easy to personalize software today. There are two general categories of prompts to an agent that make all of this possible:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;em&gt;Download the source for &amp;lt;software&amp;gt; and build it for local use. Modify &amp;lt;whatever memory your agent uses&amp;gt; to know that any future changes to this software mean changing the sources and replacing the current version. Record in version control the original motivation behind the change.&lt;/em&gt;&lt;br /&gt;
&lt;br /&gt;
and, &lt;strong&gt;more importantly&lt;/strong&gt;:&lt;/li&gt;
&lt;li&gt;&lt;em&gt;Set up a nightly cron job that executes the prompt: fetch upstream changes to the &amp;lt;software&amp;gt; and rebase all local changes on top of upstream. Check that the software works as intended and replace the current version.&lt;/em&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;At the heart of this is the realization that agents can not only hack up some code for a specific use but also automatically manage the process of synchronizing changes with upstream releases. This means agents change the ROI on customizing software on two fronts simultaneously: it is much easier to get started personalizing, and much easier to keep going.&lt;/p&gt;
&lt;p&gt;Another astonishing thing about the two prompts above for editing software is that you can build them right into an agent. As long as the agent is open source, it does not even require programming. The two prompts can be loaded into a skill (i.e., some text instructions) put somewhere discoverable to the agent. We built this into Shelley, so now if you want to edit Shelley you don’t even need the preamble or to configure the timer. &lt;a href=&#34;https://blog.exe.dev/customizing-shelley&#34;&gt;It takes care of it for you.&lt;/a&gt; You can type in a prompt like “make Shelley’s UI high-contrast” and you have personalized your agent.&lt;/p&gt;
&lt;h3&gt;A Worked Personalization Example: Shelley and Meat&lt;/h3&gt;
&lt;p&gt;I have a personal project I have been idly toying with for the last month: &lt;a href=&#34;https://meat.dev&#34;&gt;meat.dev&lt;/a&gt;. The principle is that while agents write code, I still read it before pushing to our serious systems. As the underlying models improve, what I look for has changed. The humans I have spent twenty years reviewing code for have always struggled with edge cases: do the errors report useful information; are nil-checks handled, etc. (We all do it; when writing code, I am one of the worst offenders.) One of my roles as a reviewer was looking for these details. Over the past six months, I have discovered I don’t need to read for edge cases like that any more: models are far more diligent than humans at rote correctness. Their errors are isolated to architecture, unexpected use cases, visual output their test environment is not feeding back to them, etc. This means most of the lines of code I review are not very useful. So I wrote a tool that takes diffs and uses LLMs to strip out the unimportant stuff. I almost never need to see the import blocks, or the nil-checks, or the error handling any more, so get it off the screen so I can focus on the meat.&lt;/p&gt;
&lt;p&gt;I like this tool, but it has two downsides: first, I like to read my diffs in Shelley with a good UI, not in a terminal. Second, it takes a couple of minutes for an LLM to digest and minimize a diff, and I don’t want to wait. So ideally I would not run &lt;code&gt;meat&lt;/code&gt; on the command line, but have it built into Shelley and have it pre-processing commits the moment they are created. It turns out I can do that with a single prompt:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Please build meat.dev into Shelley. Install the latest version in the PATH. When a git commit is created by Shelley, start meat processing in the background on the commit. Add a toggle to the Shelley &lt;code&gt;Diffs&lt;/code&gt; view for meat. If the commit is still being processed, so the user it is in process.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;This single prompt was all it took not just to add meat to Shelley, but to appropriately pre-process commits in the background before I came back to session to review the diff, saving me waiting for a model to reduce the diff. The only unfortunate choice the model made was using the 🥩 emoji for the toggle button.&lt;/p&gt;
&lt;p&gt;Imagine the convoluted misery it would be trying to plug that into the VS Code extensions API! Or trying to get it into &lt;code&gt;vimdiff&lt;/code&gt;. It would certainly be possible, but the machinery to start pre-processing the commits as soon as they appear would be nigh-on impossible. I would be better off implementing an out-of-band &lt;code&gt;meatd&lt;/code&gt; that listened to the file system and provided a cache for the &lt;code&gt;meat&lt;/code&gt; tool that a customization API could use, because the points of extension and configuration would not be the right shape.&lt;/p&gt;
&lt;p&gt;And that is the fundamental difference between classic configuration/customization and agent-driven personalization: you can do so much more. The agent will do the hard work of understanding the source and changing it to suit the particular task you have in mind. The software we live with is far more powerful with personalization. All you need is the source code.&lt;/p&gt;
&lt;h2&gt;The Age of Personalized Software&lt;/h2&gt;
&lt;p&gt;The pre-agent development costs meant it was rational for complex software to ship with large configuration files, extension systems, and plugin systems. The core code of even a moderate project like Vim is huge and baroque, and takes weeks for a human to digest. The thought that, on wanting line numbers to print by default, an engineer would learn the code base and add it just for themselves is unreasonable. Better to design it for sharing with others, which justifies the expense of implementing it by amortizing it over many users. As features in a code base grow, it makes sense to look for common abstractions where you can break out an extension or plugin system.&lt;/p&gt;
&lt;p&gt;Now the expense of learning the code and making a change has dropped dramatically. Agents do the heavy lifting. For a single user—which implies extremely constrained conditions under which the program runs—a top-end agent can usually now add a feature in a single shot. For single-user software, the need for careful code review can often be replaced by “does it seem to work?”&lt;/p&gt;
&lt;p&gt;The result is that software that can be personalized doesn’t need a plugin system or a config file. Want to change the font size in your text editor? Give the agent the source and tell it to. If it is a hardcoded value it will find and edit it. If it’s a hardcoded bitmap font it will download another and replace it, or it will use Monobit to make you one! You have incredible capabilities on tap.&lt;/p&gt;
&lt;h2&gt;Whole Categories of Software Products Need to Be Reinvented&lt;/h2&gt;
&lt;p&gt;Personal software applies well to small teams too. Why would an engineering team purchase an extremely configurable task manager (or a CMS or CRM), spend time learning and configuring it, and contort their team to its limits, when they can assemble just the features they want from common building blocks?&lt;/p&gt;
&lt;p&gt;Both the upfront fixed costs and the ongoing costs of personalizing software have disappeared.&lt;/p&gt;
&lt;p&gt;The blog you are reading is bespoke software, written in Shelley, because it was easier to piece together and personalize libraries like Tiptap than it is to try and customize traditional software products. For end-user products to make sense in a company today, they need to be personalizable. Which means we need the source code.&lt;/p&gt;
&lt;h2&gt;Where Codex and Claude Code Diverge&lt;/h2&gt;
&lt;p&gt;This same skill-based technique that was applied to Shelley to make it personalizable can be trivially applied to other open-source agents like Pi. (So much so that I am left wondering why Pi needs an extension system built into it. The source code is the extension system.) It would require a lot more tokens, but you could do the same to Codex, which is an open-source agent.&lt;/p&gt;
&lt;p&gt;Where you would hit a wall, however, is Claude Code. It is closed-source software, so you don’t get to personalize it. There are a lot of old-fashioned customization hooks in Claude Code. Hopefully, how you want an agent to work fits in their hooks. If not, switch to an agent that lets you personalize it.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Stripe Just Wants a Number</title>
    <link href="https://blog.exe.dev/billable-facts" />
    <id>https://blog.exe.dev/billable-facts</id>
    <updated>2026-07-29T13:00:00Z</updated>
    <summary>Inside exe’s billable facts architecture.</summary>
    <content type="html">&lt;p&gt;If you went up to an engineer at any tech company and asked “What’s your favorite part of the stack to work on?” I can guarantee their answer wouldn’t align with my own: billing.&lt;/p&gt;
&lt;p&gt;In my experience, billing becomes difficult when billing logic gets tangled up with regular business logic. You end up with code touching every hot path that needs to do a billing operation. Even with LLMs, it’s a struggle to not have it sprawl everywhere. Startups can’t afford this because it leads to brittle pricing structures that are hard to change—and no startup can allocate time to rewrite billing. Instead, we should have product events tell the billing system “something changed and you may need to charge for it.” I call these billable facts.&lt;/p&gt;
&lt;p&gt;Here at exe, my goal is to make sure that anyone can work on billing and when the weird idiosyncrasies show up, I can step in. We can’t afford to have one person hold all the billing information and for that to be their sole focus. Exe doesn’t do code reviews, which means we have a different approach to writing code. We all have the right to change any code in our system. The trade-off is it’s like owning a car: anyone can DIY the majority of the work. Once a head gasket blows, you’re dealing with the engine and hundreds of parts. I’m the one who has to fix the head gasket.&lt;/p&gt;
&lt;p&gt;In our earliest days of billing, we did the usual approach: some giant function that does all the things and has a billing side effect. Adding a seat to a team was one such example:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;The team invites someone to join in a specific role.&lt;/li&gt;
&lt;li&gt;The user accepts the invitation, verifies their account, and joins the team.&lt;/li&gt;
&lt;li&gt;The user gains access to the team’s shared VMs.&lt;/li&gt;
&lt;li&gt;The user gets allocated a certain amount of compute resources based on their team’s plan.&lt;/li&gt;
&lt;li&gt;The new user can use &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev.&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;We figure out how to charge for this seat through a series of handwaving akin to Pee-wee’s breakfast machine.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;The first implementation of billing for seats worked. In the middle of these database changes (wrapped in a transaction), we also issued billing API calls to our provider. Anyone who has written billing code before has probably done this. But the usual questions present themselves:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;What happens if the API call fails?&lt;/li&gt;
&lt;li&gt;What happens if the database transaction fails?&lt;/li&gt;
&lt;li&gt;What happens if the team has a weird subscription state?&lt;/li&gt;
&lt;li&gt;What happens if the payment is declined when charging for the seat?&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I knew this would become increasingly brittle—a pileup of billing edge cases.&lt;/p&gt;
&lt;p&gt;Rather than shipping it and calling it done (like I might have done in a past life), I decided to think about the problem differently. Instead of having billing API calls littered in the code, what if we issued &lt;strong&gt;billable facts&lt;/strong&gt; about the state of something and reconciled billing once the new facts were settled? Billable facts are atomic operations that indicate something has changed. Using the facts, we could perform any business logic, establish the new state of a resource, and then finally reconcile the state with our billing provider. After all, Stripe just wants a number. It doesn’t care how we get there.&lt;/p&gt;
&lt;p&gt;This is the new product flow:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;The team invites someone to join in a specific role.&lt;/li&gt;
&lt;li&gt;The user accepts the invitation, verifies their account, and joins the team.&lt;/li&gt;
&lt;li&gt;The user gains access to the team’s shared VMs.&lt;/li&gt;
&lt;li&gt;The user gets allocated a certain amount of compute resources based on their team’s plan.&lt;/li&gt;
&lt;li&gt;The new user can use &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev.&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;And this is how it works on the billing side:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;During the invitation flow, the team seat state is flagged as dirty after the invitation is accepted.&lt;/li&gt;
&lt;li&gt;A downstream worker notices the team is flagged as dirty.&lt;/li&gt;
&lt;li&gt;The worker calculates a seat delta based on business rules.&lt;/li&gt;
&lt;li&gt;The worker updates the subscription quantity in Stripe if the delta changed.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;With this architecture, onboarding a new team member is no longer dependent on our billing code. If we wanted to change how the seat delta is calculated, it would have no impact on adding new team members.&lt;/p&gt;
&lt;p&gt;As exe continues to grow, this billing pattern has been scaling well. The same reconciliation process runs for all our metered billing. Our system issues billable facts about active VMs, like disk usage, and metering workers reconcile with billing providers. Even as we add different ways to bill users, these facts don’t change. Instead, the effort shifts towards figuring out how to reconcile facts with various APIs. We’ve seen the benefits with our iOS app, which just tells our system “someone subscribed with an in-app purchase” and things reconcile after the fact.&lt;/p&gt;
&lt;p&gt;Billing is slowly becoming approachable for others here. Like the rest of our code, our billing architecture has given people the flexibility to make changes as they see fit. I don’t have to worry about billing breaking because someone decides to rewrite how invites work. It’s nice to not have folks tap “Bryan GPT” to do a billing task.&lt;/p&gt;
</content>
    <author>
      <name>Bryan Mikaelian</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>tailmix: Connect to Multiple Tailnets at Once</title>
    <link href="https://blog.exe.dev/a-tale-of-two-tailnets" />
    <id>https://blog.exe.dev/a-tale-of-two-tailnets</id>
    <updated>2026-07-24T00:00:00Z</updated>
    <summary>An independent, open-source client that lets one machine connect to multiple tailnets simultaneously.</summary>
    <content type="html">&lt;p&gt;Tailscale is one of those magical technologies that I can no longer imagine living without. Its use cases range from homelab setups to enterprise workloads spread across complex, disparate environments. At exe, we use it to connect much of our internal infrastructure.&lt;/p&gt;
&lt;p&gt;That said, there are points of friction. One of my pet peeves is having to switch tailnets whenever I want to briefly connect to Home Assistant or Frigate to see who’s at the door while working on exe’s infrastructure. Tailscale’s &lt;a href=&#34;https://tailscale.com/blog/fast-user-switching&#34;&gt;fast user switching&lt;/a&gt; helps, but switching still disconnects one tailnet before connecting the other. That disrupts existing connections, takes a few seconds, and requires me to remember to switch back.&lt;/p&gt;
&lt;p&gt;Why can’t I just be connected to multiple tailnets at the same time?&lt;/p&gt;
&lt;p&gt;A few technical complications make it tricky, starting with the fact that Tailscale &lt;a href=&#34;https://tailscale.com/blog/choose-your-ip&#34;&gt;allocates IPv4 addresses independently&lt;/a&gt; within each tailnet. This means two nodes in two different tailnets can end up with the same IPv4 address. If both tailnets were connected simultaneously, the address alone wouldn’t tell the client which node I intended to reach.&lt;/p&gt;
&lt;p&gt;I &lt;a href=&#34;https://tailscale.com/docs/reference/troubleshooting/network-configuration/cgnat-conflicts&#34;&gt;could disable IPv4&lt;/a&gt; and use IPv6 exclusively, but that still doesn’t work everywhere. It’s getting better, but the long tail is, well, long. Disabling IPv4 requires updating the Tailscale policy file and passing some pain along to my teammates, which feels unjustified.&lt;/p&gt;
&lt;p&gt;Node sharing has similar challenges. Tailscale does the work of making sure those IPs don’t collide, but it requires that I be an admin on both tailnets, and I’d have to individually share every device I wanted to reach. As my kid is fond of saying: I don’t want to!&lt;/p&gt;
&lt;p&gt;A couple of weeks ago, I wondered whether I could have an agent write me a new Tailscale client that would let me connect to multiple tailnets at once. As usual, I spun up a new VM on exe and told &lt;a href=&#34;https://blog.exe.dev/shelley&#34;&gt;Shelley&lt;/a&gt; about my problem, and we went back and forth on the design until I was convinced the solution would work for the vast majority of use cases.&lt;/p&gt;
&lt;p&gt;The solution was fairly straightforward: spin up a couple of &lt;code&gt;tsnet.Server&lt;/code&gt; instances, put them behind a single TUN interface, assign each peer node in each tailnet a new IPv4 from a locally configured pool such as &lt;code&gt;10.58.0.0/16&lt;/code&gt;, and hijack MagicDNS to return those IPs. Traffic sent to one of them is then routed through the corresponding tailnet.&lt;/p&gt;
&lt;p&gt;It worked the first time I tried it. All of the Tailscale policies worked just as they should, and I didn’t have to implement any of that, as the upstream &lt;code&gt;tsnet.Server&lt;/code&gt; is a full-fledged Tailscale client already.&lt;/p&gt;
&lt;p&gt;The result is &lt;a href=&#34;https://github.com/maisem/tailmix&#34;&gt;tailmix&lt;/a&gt;, an independent, open-source client that lets one machine connect to multiple tailnets simultaneously. The source, installation instructions, and current limitations are all in the repository—or you can ask &lt;a href=&#34;https://exe.dev/new?prompt=clone%20the%20github.com/maisem/tailmix%20repo%20and%20tell%20me%20how%20it%20works&#34;&gt;Shelley&lt;/a&gt; to tell you all about it.&lt;/p&gt;
&lt;p&gt;I still have two tailnets, two identities, and two separate sets of policies. The difference is that now my laptop no longer makes me choose between them.&lt;/p&gt;
</content>
    <author>
      <name>Maisem Ali</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Customizing Shelley, Customizing Software</title>
    <link href="https://blog.exe.dev/customizing-shelley" />
    <id>https://blog.exe.dev/customizing-shelley</id>
    <updated>2026-07-22T16:00:00Z</updated>
    <summary>With a coding agent living next to your software, customizing it is as easy as asking. Shelley even rebases your changes onto each upgrade.</summary>
    <content type="html">&lt;style&gt;
.carousel { margin: 2em 0; }
.carousel-track {
  display: flex;
  overflow-x: auto;
  scroll-snap-type: x mandatory;
  -webkit-overflow-scrolling: touch;
  scroll-behavior: smooth;
  scrollbar-width: none;
}
.carousel-track::-webkit-scrollbar { display: none; }
.carousel-slide {
  flex: 0 0 100%;
  scroll-snap-align: center;
}
.carousel-slide figure { margin: 0; text-align: center; }
.carousel-slide img {
  max-width: 100%;
  max-height: 460px;
  width: auto;
  border-radius: 8px;
  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.15);
}
.carousel-slide figcaption {
  margin-top: 8px;
  font-size: 0.9em;
  color: #888;
}
.carousel-nav {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 10px;
  margin-top: 12px;
}
.carousel-arrow {
  flex: 0 0 auto;
  width: 42px;
  height: 42px;
  border: none;
  border-radius: 50%;
  background: rgba(0, 0, 0, 0.45);
  color: #fff;
  font-size: 20px;
  line-height: 1;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  transition: background 0.2s;
  -webkit-tap-highlight-color: transparent;
}
.carousel-arrow:hover { background: rgba(0, 0, 0, 0.7); }
.carousel-thumbs {
  display: flex;
  gap: 8px;
}
.carousel-thumbs button {
  padding: 0;
  border: 2px solid transparent;
  border-radius: 6px;
  background: none;
  cursor: pointer;
  line-height: 0;
  opacity: 0.55;
  transition: opacity 0.2s, border-color 0.2s;
  -webkit-tap-highlight-color: transparent;
}
.carousel-thumbs button:hover { opacity: 0.85; }
.carousel-thumbs button[aria-current=&#34;true&#34;] {
  opacity: 1;
  border-color: rgba(128, 128, 128, 0.9);
}
.carousel-thumbs img {
  width: 64px;
  height: 42px;
  object-fit: cover;
  border-radius: 4px;
  display: block;
}
&lt;/style&gt;
&lt;div class=&#34;carousel&#34;&gt;&lt;div class=&#34;carousel-track&#34; id=&#34;cs-carousel&#34;&gt;
    &lt;div class=&#34;carousel-slide&#34;&gt;&lt;figure&gt;&lt;img src=&#34;/assets/customizing-shelley-2.png&#34; alt=&#34;A Shelley conversation transcript where the user says &#39;Make shelley pink&#39; and Shelley activates the customizing-shelley skill.&#34;&gt;&lt;figcaption&gt;Asking Shelley to make itself pink.&lt;/figcaption&gt;&lt;/figure&gt;&lt;/div&gt;    &lt;div class=&#34;carousel-slide&#34;&gt;&lt;figure&gt;&lt;img src=&#34;/assets/customizing-shelley-1.png&#34; alt=&#34;Shelley reports the pink binary is installed and a restart is scheduled.&#34;&gt;&lt;figcaption&gt;Sure is pink.&lt;/figcaption&gt;&lt;/figure&gt;&lt;/div&gt;    &lt;div class=&#34;carousel-slide&#34;&gt;&lt;figure&gt;&lt;img src=&#34;/assets/customizing-shelley-3.png&#34; alt=&#34;Shelley&#39;s Version dialog showing a CUSTOMIZED build with an &#39;Upgrade: rebase onto latest&#39; button.&#34;&gt;&lt;figcaption&gt;Pink upgrade screen automates rebase.&lt;/figcaption&gt;&lt;/figure&gt;&lt;/div&gt;  &lt;/div&gt;  &lt;div class=&#34;carousel-nav&#34;&gt;
    &lt;button type=&#34;button&#34; class=&#34;carousel-arrow prev&#34; id=&#34;cs-prev&#34; aria-label=&#34;Previous image&#34;&gt;‹&lt;/button&gt;    &lt;div class=&#34;carousel-thumbs&#34; id=&#34;cs-thumbs&#34;&gt;
      &lt;button type=&#34;button&#34; aria-label=&#34;Show image 1&#34; aria-current=&#34;true&#34;&gt;&lt;img src=&#34;/assets/customizing-shelley-2.png&#34; alt=&#34;&#34;&gt;&lt;/button&gt;      &lt;button type=&#34;button&#34; aria-label=&#34;Show image 2&#34;&gt;&lt;img src=&#34;/assets/customizing-shelley-1.png&#34; alt=&#34;&#34;&gt;&lt;/button&gt;      &lt;button type=&#34;button&#34; aria-label=&#34;Show image 3&#34;&gt;&lt;img src=&#34;/assets/customizing-shelley-3.png&#34; alt=&#34;&#34;&gt;&lt;/button&gt;    &lt;/div&gt;    &lt;button type=&#34;button&#34; class=&#34;carousel-arrow next&#34; id=&#34;cs-next&#34; aria-label=&#34;Next image&#34;&gt;›&lt;/button&gt;  &lt;/div&gt;&lt;/div&gt;
&lt;script&gt;
(function () {
  var track = document.getElementById(&#34;cs-carousel&#34;);
  var thumbs = Array.prototype.slice.call(document.querySelectorAll(&#34;#cs-thumbs button&#34;));
  if (!track || !thumbs.length) return;
  var slides = track.querySelectorAll(&#34;.carousel-slide&#34;);

  function go(i) {
    if (i &lt; 0) i = 0;
    if (i &gt; slides.length - 1) i = slides.length - 1;
    slides[i].scrollIntoView({ behavior: &#34;smooth&#34;, block: &#34;nearest&#34;, inline: &#34;center&#34; });
  }
  function current() {
    var i = Math.round(track.scrollLeft / track.clientWidth);
    return Math.max(0, Math.min(slides.length - 1, i));
  }

  thumbs.forEach(function (t, i) { t.addEventListener(&#34;click&#34;, function () { go(i); }); });
  document.getElementById(&#34;cs-prev&#34;).addEventListener(&#34;click&#34;, function () { go(current() - 1); });
  document.getElementById(&#34;cs-next&#34;).addEventListener(&#34;click&#34;, function () { go(current() &#43; 1); });

  function sync() {
    var i = current();
    thumbs.forEach(function (t, j) { t.setAttribute(&#34;aria-current&#34;, j === i ? &#34;true&#34; : &#34;false&#34;); });
  }
  var raf;
  track.addEventListener(&#34;scroll&#34;, function () {
    if (raf) cancelAnimationFrame(raf);
    raf = requestAnimationFrame(sync);
  });
})();
&lt;/script&gt;
&lt;p&gt;If you want to customize Shelley, open up a conversation, and ask the agent to change itself. It will do so. When a new version of Shelley ships, it rebases your customizations onto the latest version, so your changes always carry forward.&lt;/p&gt;
&lt;p&gt;The traditional approach to software customization has been configuration and plug-in architectures. With the advent of coding agents, a third way is viable: edit the code. The tool exists to serve you, so &lt;a href=&#34;https://blog.exe.dev/software-as-wiki&#34;&gt;treat it like a wiki&lt;/a&gt;, slap an &amp;quot;Edit With Shelley&amp;quot; ribbon on it, and go to town.&lt;/p&gt;
&lt;p&gt;Give customizing Shelley a shot! When you&#39;ve got features that can stand the test of time, &lt;a href=&#34;https://exe.dev/docs/getting-help&#34;&gt;pop into our Discord&lt;/a&gt;, and let us know.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>How Antithesis Turned exe into a Sandbox for Agentic Software Tests</title>
    <link href="https://blog.exe.dev/how-antithesis-turned-exe-into-a-sandbox-for-agentic-software-tests" />
    <id>https://blog.exe.dev/how-antithesis-turned-exe-into-a-sandbox-for-agentic-software-tests</id>
    <updated>2026-07-22T13:00:00Z</updated>
    <summary>&#34;There&#39;s this tension between giving [agents] enough power and then also not letting them destroy the world.&#34;</summary>
    <content type="html">&lt;p&gt;Carl Sverre spends a lot of time thinking about how to give AI agents the right amount of power. Give them too little, and they can’t do real work. Give them too much, and they might blow up your tech stack. As a software engineer at &lt;a href=&#34;https://antithesis.com/&#34;&gt;Antithesis&lt;/a&gt;, an autonomous software testing platform, that question is core to how Sverre thinks about designing tools in the era of advanced AI. &lt;/p&gt;
&lt;p&gt;The solution he found began with figuring out the ideal place for agents to work. At the start of this exploration, he tried out the obvious options but found himself frustrated by their restrictions. Local sandboxes in particular were too limiting. &amp;quot;As soon as the AI wants to do something out of that boundary, it gets blocked,&amp;quot; Sverre explains. The bigger platforms, in contrast, were designed for shipping AI products. What he actually wanted was something simpler: &amp;quot;I just realized what I wanted was, like, a computer,&amp;quot; he says. &lt;/p&gt;
&lt;p&gt;That’s when Sverre remembered exe. “I was like, ‘oh, yeah, like, David is doing this weird little AI project,’” he says. He signed up and launched his first VM. “I was just so impressed by the UX,” he says. “It was so easy. And then the pricing model was perfect. It solves, in my opinion, the most critical issue with sandboxes.”&lt;/p&gt;
&lt;p&gt;That issue, in a nutshell, is that many sandbox providers charge per VM. Spin up ten sandboxes, and you pay for all ten, whether or not you’re using them simultaneously. &lt;/p&gt;
&lt;p&gt;Exe works differently. A team account, which costs $25 per user per month, gives each person access to up to 50 VMs that draw from their own pool of resources. Nobody has to track how many they’re running or whether they’ve remembered to shut them down. &amp;quot;I don&#39;t want to ever have to feel like I&#39;m spending money when I create a sandbox,&amp;quot; Sverre says. &amp;quot;I shouldn&#39;t have to worry about my finance team asking me why I spent another two dollars.&amp;quot;&lt;/p&gt;
&lt;p&gt;Sverre quickly incorporated exe into his workflow. As a bug catcher, a lot of his work revolves around testing open source projects. &amp;quot;I basically just changed my workflow to be like, spin up an exe machine, check out the project, open up Claude, ask a bunch of questions, and then throw away the VM,&amp;quot; he says.&lt;/p&gt;
&lt;p&gt;Some projects, however, need more than a one-off VM. Sverre does much of the development for &lt;a href=&#34;https://github.com/antithesishq/snouty&#34;&gt;Snouty&lt;/a&gt;, Antithesis’ command line tool, inside a persistent machine. &amp;quot;I have Claude running there and I drive that VM through Claude remote control,&amp;quot; he says. &amp;quot;I basically just have access to a persistent Claude session on my phone and on the web browser.&amp;quot;&lt;/p&gt;
&lt;p&gt;In exe’s early days, Sverre noticed that any user could click a button and share their VM with the public. “I immediately was like, that&#39;s just not a thing we can have,&amp;quot; he says. Luckily, with a small startup, that was an easy fix. &lt;/p&gt;
&lt;p&gt;Sverre filed a feature request with exe engineer Philip Zeyliger. &amp;quot;Two or three days later, it showed up in the product,&amp;quot; Sverre says. The solution—restricting who can make a VM public—allowed him to roll exe out more broadly. &amp;quot;I don&#39;t have to worry as much,&amp;quot; he says. &lt;/p&gt;
&lt;p&gt;Sverre keeps coming back to two core differentiators. First, root access: &amp;quot;We love the fact that you have root on the VM. So the AI can do basically whatever it needs to do to accomplish some task, which is really nice,” he says.&lt;/p&gt;
&lt;p&gt;Second, how exe handles idle VMs. &amp;quot;Every other VM platform on the planet hibernates your VMs,&amp;quot; he says. &amp;quot;Exe is the only one that doesn&#39;t do that.&amp;quot; In practice, it works out the same—an idle VM&#39;s resources get used by other VMs instead—but there’s no delay when an idle VM boots back up. &amp;quot;You never have to think about, is it running, is it not running.”&lt;/p&gt;
&lt;p&gt;Sverre is now thinking about what an expanded version of this workflow could look like—VMs that spin up other VMs and divide up work automatically. &amp;quot;I&#39;m right on the edge of building more of an automated software factory where I want to have VMs be created by other VMs,&amp;quot; he says. It&#39;s still early days, but the underlying question hasn&#39;t changed: how much power do you give an agent to work—and how do you make sure it’s totally safe?&lt;/p&gt;
&lt;p&gt;&amp;quot;There&#39;s this tension between giving them enough power and then also not letting them destroy the world,&amp;quot; Sverre says. &amp;quot;exe is that solution for us.&amp;quot;&lt;/p&gt;
</content>
    <author>
      <name>Zoe</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Run a Slack Bot from Your VM (Without Giving It the Keys)</title>
    <link href="https://blog.exe.dev/run-a-slack-bot-from-your-vm-without-giving-it-the-keys" />
    <id>https://blog.exe.dev/run-a-slack-bot-from-your-vm-without-giving-it-the-keys</id>
    <updated>2026-07-22T00:00:00Z</updated>
    <summary>Send-only or fully bidirectional, with the permissions you choose.</summary>
    <content type="html">&lt;p&gt;You can now interact with your VM on Slack. We store your Slack credentials outside your VM so you don’t have to worry about agents running amok (incidentally, that’s true of all our integrations). There are two flavors of Slack integration:&lt;/p&gt;
&lt;h2&gt;Slack&lt;/h2&gt;
&lt;p&gt;The first is a send-only version of Slack (just labelled “Slack” on the integrations page). You can read more about it here: &lt;a href=&#34;https://exe.dev/docs/integrations-slack&#34;&gt;https://exe.dev/docs/integrations-slack&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Hooking it up is simple. When you create an integration, you will be directed to Slack to choose a workspace and channel. Then, attach the integration to a VM and call it from there:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl --json &amp;#39;{&amp;#34;text&amp;#34;:&amp;#34;Everything is groovy&amp;#34;}&amp;#39; https://&amp;lt;slack-integration-name&amp;gt;.int.exe.xyz/
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Your message will show up in the linked channel.&lt;/p&gt;
&lt;h2&gt;Slack Bot&lt;/h2&gt;
&lt;p&gt;The second flavor is a little more complex, but much more flexible. It’s called “Slack Bot” on the integrations page. It will allow you to make a fully fledged Slack bot that can read/write and do whatever else you give it permissions to do. The setup is a little more involved because you need to &lt;em&gt;make&lt;/em&gt; the app and grant it all the permissions you want your bot to have. More detailed instructions are on the documentation page: &lt;a href=&#34;https://exe.dev/docs/integrations-slack-bot&#34;&gt;https://exe.dev/docs/integrations-slack-bot&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Once you’ve created your app, drop its two tokens into the integration. Then you can do a simple curl call to write to the channel: &lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl -X POST https://&amp;lt;slackbot-integration-name&amp;gt;.int.exe.xyz/api/chat.postMessage --json &amp;#39;{&amp;#34;channel&amp;#34;: &amp;#34;#exe-dev-integration-test&amp;#34;,&amp;#34;text&amp;#34;:&amp;#34;hi&amp;#34;}&amp;#39;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Or you can make a full-blown responsive chatbot. There’s demo code included in the documentation.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/image_720.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Have fun and enjoy slacking!&lt;/p&gt;
</content>
    <author>
      <name>Danny Krause</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Claude Is Not a Compiler</title>
    <link href="https://blog.exe.dev/claude-is-not-a-compiler" />
    <id>https://blog.exe.dev/claude-is-not-a-compiler</id>
    <updated>2026-07-21T13:00:00Z</updated>
    <summary>Or: the difference between vibe-coding and vibe-engineering.</summary>
    <content type="html">&lt;p&gt;In early 2025, I wrote &lt;a href=&#34;https://commaok.xyz/ai/is-claude-a-compiler/&#34;&gt;Is Claude a Compiler&lt;/a&gt;? At the time, my answer was: I don’t know.&lt;/p&gt;
&lt;p&gt;I’m now pretty sure the answer is “no, that’s a category error, it’s &lt;em&gt;better&lt;/em&gt; than a compiler.” But this requires a bit of unpacking.&lt;/p&gt;
&lt;p&gt;Computer programs are notoriously intricate and finicky. A program operates at an extreme level of precision. There is no “wave hands” CPU instruction. High-level goals, meanwhile, are deeply underspecified.&lt;/p&gt;
&lt;p&gt;In a highly stylized view of the world, software gets built in layers, each one adding specification and hiding “unnecessary” detail. Vision becomes strategy, product plans become coding plans, code becomes binaries. Each step is handled by a different role: executive, VP, PM, architect, engineer, compiler. &lt;/p&gt;
&lt;p&gt;Critically, every step involves making lots of decisions. That’s what it &lt;em&gt;means&lt;/em&gt; to increase the level of specification. (This is why one of my two key metrics for hiring engineers is judgment. The other is comity.)&lt;/p&gt;
&lt;p&gt;The bottom layer, from source code to binary, is what a compiler does. Compilers make lots of decisions! Inlining, register allocation, whether to emit warnings or reject a program outright. And these decisions matter: They drive performance, system stability, predictability, and failure modes. A compiler engineer’s job is to arrange for the compiler to make consistently good decisions.&lt;/p&gt;
&lt;p&gt;A good, trusted compiler frees a software engineer from having to make these decisions. Most engineers have little idea how compilers work; they don’t need to in order to be effective. &lt;/p&gt;
&lt;p&gt;In 2025, we operated in a world where we used LLMs to generate smallish chunks of code. In this mental model, a coding agent might slot in as a new layer between a software engineer and a traditional compiler. It “compiles” natural language to code, making decisions so the engineer doesn’t have to. Its value is proportional to its reliability and the scale of the decisions it can make.&lt;/p&gt;
&lt;p&gt;The thing is, this highly stylized view of the world is false. Abstractions leak and &lt;a href=&#34;https://www.dbreunig.com/2026/07/03/ai-ecosytem-pace-layers.html&#34;&gt;layers rub&lt;/a&gt;. And even if they didn’t, we’d poke holes in them anyway.&lt;/p&gt;
&lt;p&gt;Working across layers is extremely valuable; mechanical sympathy matters.&lt;/p&gt;
&lt;p&gt;Part of how the &lt;a href=&#34;https://www.construction-physics.com/p/building-fast-and-slow-the-empire&#34;&gt;Empire State Building was constructed&lt;/a&gt; in under a year and under budget (!!) was by systematically working across layers. For example, when deciding about the exterior chrome-nickel steel cladding:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Neither architects, builders nor subcontractors felt competent to deal with this complicated technical problem of construction without full consultation. Accordingly, after full preliminary discussion, an all-inclusive meeting was called which was attended by representatives of the owner, the architects and builders, the subcontractors rolling the material, the metal workers who were to fabricate and those who were to erect it, and the inspectors who were to test all sheets at the several stages of preparation.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;This sounds really obvious when you say it out loud.&lt;/p&gt;
&lt;p&gt;And yet we systematically fail at this in practice. I can only imagine the delight of the metal workers who had an opportunity to guide the design toward something that wasn’t slow and miserable to work on.&lt;/p&gt;
&lt;p&gt;Part of the reason we fail is ignorance of what is even worth asking about. There’s a reason that &lt;a href=&#34;https://daringfireball.net/linked/2022/10/11/ceos-as-nerds&#34;&gt;the best executives have deep knowledge of their industry&lt;/a&gt;. I also suspect that some of it is dismissiveness (“What could a line metalworker have to tell &lt;em&gt;me&lt;/em&gt;?”). But a big chunk is also communication and organizational overhead. Layers exist for a reason—information hiding enables organizational scaling.&lt;/p&gt;
&lt;p&gt;Claude is better than a compiler because it can work vertically across the stack. LLMs now talk strategy, product, architecture, code, and machine code. It can’t (yet?) do most individual tasks as well as an experienced, dedicated human, but it can do all of them, without having to schedule meetings or ask permission.&lt;/p&gt;
&lt;p&gt;Here’s a concrete example.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VMs have nice domain names: &lt;a href=&#34;http://vm-name.exe.xyz&#34;&gt;vm-name.exe.xyz&lt;/a&gt;. When we start a new VM, we add a CNAME entry or three. Easy, right?&lt;/p&gt;
&lt;p&gt;But our VMs start fast, so fast that even if we created the DNS entries before creating the VM, our users still had to sit around waiting for DNS to propagate, which occasionally took minutes, not seconds.&lt;/p&gt;
&lt;p&gt;We did the obvious thing: We wrote our own DNS server, so that DNS always immediately matched the source of truth. And life was good.&lt;/p&gt;
&lt;p&gt;But &lt;a href=&#34;https://blog.exe.dev/regions&#34;&gt;latency matters&lt;/a&gt;, so we added regions. And just like that, DNS became the long pole again, because all DNS was served out of Oregon. Also, deployments caused tiny DNS outages. To fix this, all we needed now was a geographically distributed but fully consistent DNS server.&lt;/p&gt;
&lt;p&gt;We did what a sensible engineer does when faced with a hard problem: cheat. We vibe-engineered a distributed DNS server tuned to our specific needs.&lt;/p&gt;
&lt;p&gt;The goals were clear: Reduce latency for users far from Oregon and increase uptime resiliency. But the rest was not. We had to figure out everything from the exact behavior we wanted (particularly under various failure conditions), to how it fit into our overall company plans, to the architecture that could best achieve those goals, straight through down to the fine implementation details.&lt;/p&gt;
&lt;p&gt;We hashed out the highest level strategic and architectural decisions in person. We’d make a fairly general-purpose DNS server and layer on our particular behavioral tweaks, use a hub-and-spoke model, use an append-only replication strategy, and have persistence at the edges.&lt;/p&gt;
&lt;p&gt;All that was left was to actually build it.&lt;/p&gt;
&lt;p&gt;I had LLMs research standard designs for distributed DNS systems, teach me about the guts and quirks of DNS, point out historic security failings, explore alternative implementation strategies (AXFR/IXFR? no thanks), research open source offerings, game out failure modes, and plan testing strategies.&lt;/p&gt;
&lt;p&gt;Once I had an initial sketch of a design that seemed promising, I prompted multiple concurrent agent loops into building &lt;em&gt;the entire thing&lt;/em&gt;, including tests and adversarial code review. They raised a bunch of questions—at every level of detail, from major structural approaches down to line-level code concerns. As I answered them (or reverted answers that generated regret), I slowly converted what I had learned into very terse written guidance, codifying decisions that proved to be important.&lt;/p&gt;
&lt;p&gt;Then I asked new agents to compare the completed implementations and look for interesting deviations. It was shocking how many important decisions the agents never asked about but simply made—and made differently.&lt;/p&gt;
&lt;p&gt;Here’s an example. Replication uses the fairly obvious approach: Catch up by asking for everything since the last known entry, and then long poll for new entries. There’s one ugly twist: database rollbacks. Rare, but they do happen, and they break the “append-only” contract.&lt;/p&gt;
&lt;p&gt;The agents noticed this, and they solved it in wildly different ways. The design I ultimately settled on was to give every row a “timeline” field, as in “which timeline are you living in?” These are randomly generated, and every sync request for “entries since row N” includes the edge server’s timeline value for row N. If there’s a timeline mismatch, we know that history has been altered and fall back to a full clean re-sync.&lt;/p&gt;
&lt;p&gt;There were also obvious style differences between the systems built by different agents. Claude and Codex both agreed that Claude created a more elegant system but that Codex was more thorough.&lt;/p&gt;
&lt;p&gt;I worked through the list of major identified divergences, experimented, and then added more written guidance.&lt;/p&gt;
&lt;p&gt;Then I repeated that &lt;em&gt;entire&lt;/em&gt; &lt;a href=&#34;https://commaok.xyz/ai/differential-spec/&#34;&gt;differential spec analysis&lt;/a&gt; process, twice. I know my &lt;a href=&#34;https://en.wikipedia.org/wiki/Second-system_effect&#34;&gt;aphorisms&lt;/a&gt;.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Plan to throw one away; you will, anyhow.&lt;/p&gt;
&lt;p&gt;— Fred Brooks&lt;/p&gt;
&lt;p&gt;If you plan to throw one away, you will throw away two.&lt;/p&gt;
&lt;p&gt;— Craig Zerouni&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;By the time I was ready to build a keeper, I had accumulated a scar-tissue document that was empirically sufficient to guide an agent through most of the important decisions, at every layer, ranging from high level goals through architecture down to the occasional low level detail, such as the exact shape of the data type for load-bearing concurrent caches.&lt;/p&gt;
&lt;p&gt;The final system included unit tests, end-to-end tests, a shadow-mode for de-risking prod rollout, and a terse written-by-and-for-agents doc suite.&lt;/p&gt;
&lt;p&gt;This cumulatively took about a week of my attention. I read a vanishingly small amount of the actual code.&lt;/p&gt;
&lt;p&gt;At the end of that, I presented the solution to the team. I planned to launch the server and then go on vacation. As my colleagues peppered me with questions—&amp;quot;How does X work? What happens in condition Y?&amp;quot;—I found I could answer all of them confidently. (And I did go on that vacation. Number of DNS incidents a month later: 0.)&lt;/p&gt;
&lt;p&gt;Claude wasn’t just a compiler here. I never handed off a task and let an agent make a bunch of decisions in order to reduce it to practice. That’s vibe-coding.&lt;/p&gt;
&lt;p&gt;Rather, Claude was a vertically integrated resource, a multi-compiler. Its ability to work across the stack accelerated and augmented my ability to make a bunch of decisions at different levels, including about which decisions were important. (Most individual lines of code don’t make that cut.) That’s vibe-engineering.&lt;/p&gt;
&lt;p&gt;I’d say that, in all the ways that matter, I understand the code. Sure, if I had to hand-edit it now, there’d be a serious learning curve. But I won&#39;t have to. And more importantly, I can reason about the system, share perspectives with my colleagues, and guide agents on future work. And there’s an enduring artifact that encapsulates the central, intentional aspects of the design that were important enough to record, across all layers, and should thus survive bug fixes and code churn.&lt;/p&gt;
&lt;p&gt;One of the questions of this era is: What do software engineers need to understand about the systems they work on?&lt;/p&gt;
&lt;p&gt;Well-chosen layers provide &lt;em&gt;understanding&lt;/em&gt;. Fundamental laws of physics appear all-encompassing, but they’re inferior to classical mechanics for &lt;em&gt;explaining&lt;/em&gt; why it’s better to be in a bus than a car in an accident.&lt;/p&gt;
&lt;p&gt;Some software layers are dying, because they provide convenience, but not extra insight. (Sorry, Tailwind. I loved you.) But software layers that enable us to express important decisions in a comprehensible way? Those will stay.&lt;/p&gt;
&lt;p&gt;We are shifting more of our attention up the stack, but without fully relinquishing the lower layers. Agents are not a free pass to hand off all understanding of the deeper layers of a system. Most of the Go standard library is written in Go, but a few key routines are written in assembly. You can’t rely on the compiler there.&lt;/p&gt;
&lt;p&gt;Software engineers are being stretched. It’s exhilarating and exhausting. What’s becoming clear, though, is that in the near future, vibe-engineering is just…engineering.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Meet the Conservationist Who Turned 40 Terabytes of Public Data Into a Video Game</title>
    <link href="https://blog.exe.dev/meet-the-conservationist-who-turned-40-terabytes-of-government-data-into-a-video-game" />
    <id>https://blog.exe.dev/meet-the-conservationist-who-turned-40-terabytes-of-government-data-into-a-video-game</id>
    <updated>2026-07-14T13:00:00Z</updated>
    <summary>Raffael Hickisch spent years dreaming up conservation tools he couldn&#39;t afford to build. Then he built them himself, with an AI agent and a country&#39;s worth of public data.</summary>
    <content type="html">&lt;p&gt;There’s a grass fire burning behind Raffael Hickisch when we speak on a video call on Tuesday. He’s not worried—fires like this are part of everyday life in Sub-Saharan Africa, where people burn off the tall growth as they move their cattle toward greener land. &lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/20260707_174816.jpg&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Hickisch, a conservationist, cofounded the Chinko Nature Reserve in 2014. Like many reserves, the land is managed via a public-private partnership between a nonprofit and the government—in this case, the Central African Republic. Fire data helps Hickisch track where people are moving and informs policies related to how they can use the land.&lt;/p&gt;
&lt;p&gt;Historically, Hickisch’s challenge has been cobbling together information from different sources and assembling it in a way that people can use. He’d download human settlement data, deforestation data, fire data from NASA, and use a desktop program to visualize how all the pieces worked together. &amp;quot;I hardly ever simulate it because it&#39;s just a lot of work and my computer doesn’t even support it,” he says. &lt;/p&gt;
&lt;p&gt;That challenge has real-life implications—protected areas may have designated zones where people can graze livestock seasonally and zones that are completely off-limits, but enforcing those rules requires knowing what&#39;s happening across tens of thousands of square kilometers. &amp;quot;It could be that there&#39;s deforestation happening and the government doesn&#39;t see it because they have not learned how to access the satellite-derived deforestation information,” Hickisch says. &lt;/p&gt;
&lt;h2&gt;‘It Just Works’&lt;/h2&gt;
&lt;p&gt;In January, Hickisch came across &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt;. “A friend said, ‘look, there’s this new service. It is crazy. You can build things with it and it just works,’&amp;quot; Hickisch recalls. &lt;/p&gt;
&lt;p&gt;For years, he’d had a list of ideas—apps he wanted to build, tools he felt could make his work significantly easier—but he’d never had the budget to actually do it. One—a tool for monitoring protected areas—would have cost tens of thousands of dollars to create and required the work of a professional developer. He’d sketched out what the app would do in a note to himself in 2022. Now, Hickisch gave an expanded version of the note to &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt;’s AI agent Shelley, and asked it to get to work:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Make an app 5mp.globe that displays global nature conservation effort based on GPS Exchange Format (GPX) files representing tracks of movement of park rangers, vehicles and aircraft that survey protected areas. Aggregate this over time (daily, monthly, annually) at 100 sq km pixels globally and display a zoomable global map, that reveals global conservation effort. The logic is explained in the text file &amp;quot;Five Megapixels of Global Conservation.txt&amp;quot;. Registered protected area managers, governments and non-profits can upload their data. Monthly and annual reports per protected area as outlined on &lt;a href=&#34;http://protectedplanet.org&#34;&gt;protectedplanet.org&lt;/a&gt; are prepared, the megapixel map can be downloaded at daily resolution.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Shelley was able to connect to the APIs of various public datasets, pulling the feeds into one place. Within a few hours, the first prototype of Five Megapixel Conservation was born. (Getting the app to its current state took Hickisch about 300 hours.)&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/5mp-Kafue-Fire-Trajectories-5mp_animation_2026-04-09_2026-07-07.gif&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Seeing it live for the first time, to Hickisch, was surreal. “I was super excited. I was like, &#39;Oh, this is crazy. Now I can do those things that I have proposed years before, but I don&#39;t need the budget, just my time.&#39;”&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/5mp-logging.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;h2&gt;100 VMs Running In Parallel &lt;/h2&gt;
&lt;p&gt;Hickisch’s home country of Austria publishes a LIDAR scan of the whole country every year, including the height of every object on the ground, along with high-resolution aerial photos. The files are huge—up to 15 gigabytes each—so as a general rule, nobody downloads them. &lt;/p&gt;
&lt;p&gt;After the success of the Five Megapixel Conservation app, Hickisch asked Shelley if there was a way to download a fraction of the file. There was. Using vsicurl—a feature of his mapping software—Shelley could read one slice of the data at a time. Hickisch built an app that uses 100 VMs running in parallel, each assigned to a different part of Austria, then uses a standard machine learning model to classify the objects in each photo. The height of a tree, combined with altitude, is a good proxy for age, allowing Hickisch to identify areas with the oldest forests, and those most in need of protection. &lt;/p&gt;
&lt;p&gt;Three months in, he&#39;s covered about 30 percent of the country and processed about 40 terabytes of raw data. The results are stored on Zenodo, an open-access repository run by CERN, a European lab best known for the Large Hadron Collider.&lt;/p&gt;
&lt;h2&gt;A Settlers-Style Game&lt;/h2&gt;
&lt;p&gt;To help bring this data to life, Hickisch built a simple settlers-style game where players can buy parcels of land, reforest them, and find treasures as they go. When a player clicks on a parcel, they’re shown real data from the LIDAR study, including the heights of the tallest trees on the property. &amp;quot;It’s a stupid game, but the powerful thing is the two terabytes of data that are underlying it,&amp;quot; Hickisch says. &lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;/assets/1.jpg&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Before exe, Hickisch felt like he was at a disadvantage. As a conservationist, he lacked the resources of developers and other industries vying to use the land. &amp;quot;Think about oil exploration,” he says. “Those people have huge budgets for their analysis. Nature conservation doesn&#39;t have that. So it&#39;s a nice moment to use that as leverage and say, actually, we now have the same tools.&amp;quot;&lt;/p&gt;
&lt;p&gt;The apps are open source, and Hickisch doesn&#39;t expect to make money from them anytime soon. What he wants is adoption—two countries using Five Megapixel Conservation to monitor their parks within the next few years. The larger goal is to get more people building custom software. &amp;quot;You can now show somebody in the Central African Republic how to build a web app,&amp;quot; he says, &amp;quot;and they will be the first member of the ministry to be able to do that.&amp;quot;&lt;/p&gt;
</content>
    <author>
      <name>Zoe</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Building Software From My Phone</title>
    <link href="https://blog.exe.dev/building-software-from-your-phone" />
    <id>https://blog.exe.dev/building-software-from-your-phone</id>
    <updated>2026-07-06T00:00:00Z</updated>
    <summary>Voice transcription, a share sheet, and a VM that&#39;s already running.</summary>
    <content type="html">&lt;p&gt;My little town of San Anselmo has a delightful &lt;a href=&#34;https://www.liveontheavenue.org&#34;&gt;live music concert series in the summer&lt;/a&gt;. What they don’t have is a website that is easy to read on my phone.&lt;/p&gt;
&lt;p&gt;I was on vacation when this summer’s schedule posted–and I had intentionally left my laptop at home.&lt;/p&gt;
&lt;p&gt;My first instinct was to ask ChatGPT to paw through and organize a schedule to my tastes, but recently I’ve noticed that farming out such tasks to Pro is lossy. I’d say it lacks serendipity, but it’s more than that. My preferences may appear superficial (bluegrass, please), but in reality, none of us are quite so reducible. Our opinions are complex and only coarsely approximated by what we might think to tell an agent.&lt;/p&gt;
&lt;p&gt;So instead, I pulled out my phone, opened the &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; iOS app, created a new VM, and said to Shelley:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;a href=&#34;https://www.liveontheavenue.org&#34;&gt;https://www.liveontheavenue.org&lt;/a&gt; please organize and analyze all of the events, movies, and bands. Add times and genres to each. Turn the whole thing into a simple, compact calendar that I can browse and scroll through on a single page. Use subagents to confirm band genres. Add a genre filter at the top, maybe a dropdown with checkboxes? Mobile-friendly.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;br /&gt;
A few minutes later I had &lt;a href=&#34;https://live-on-the-avenue.exe.xyz/&#34;&gt;https://live-on-the-avenue.exe.xyz/&lt;/a&gt; up and running. And it turns out the band I’m most excited for is listed under ska and klezmer.&lt;/p&gt;
&lt;div class=&#34;img-row&#34;&gt;
&lt;img src=&#34;/assets/live_official.png&#34; alt=&#34;&#34;&gt;
&lt;img src=&#34;/assets/1783380565-live_josh.png&#34; alt=&#34;&#34;&gt;
&lt;/div&gt;
&lt;h2&gt;Sow on the Go&lt;/h2&gt;
&lt;p&gt;The curse of having an interesting job is that you think about it all the time. I used to send myself a dozen emails a day with ideas and tasks and bug reports. Each of these was a seed for some work, to be completed later at a computer. Now that my development environment lives on &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VMs, I plant these on the go.&lt;/p&gt;
&lt;p&gt;Because I hate typing on my phone, I added high-quality transcription to the &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt;&lt;a href=&#34;https://apps.apple.com/us/app/exe-dev/id6759881448&#34;&gt; iOS app&lt;/a&gt;. In addition to being more pleasant than typing, it’s also faster. And, because I’m talking, I naturally provide more content and context, which lends itself to better results.&lt;/p&gt;
&lt;p&gt;For many tasks, reaping and/or weeping (reviewing, testing, deciding what’s actually good) still ultimately requires a laptop. But kicking off work no longer means routing it through tedious, intermediate steps.&lt;/p&gt;
&lt;h2&gt;Voice Triage&lt;/h2&gt;
&lt;p&gt;At any given point, some of my agents are working, some are blocked on trivial stuff, and some need my serious, sustained attention.&lt;/p&gt;
&lt;p&gt;I can now burn through the trivial stuff rapidly from my phone while taking a walk, getting some sunlight, or tidying the house. I put in my headphones, start up real time voice mode, and work through outstanding Shelley conversations: respond, archive, spin up a new thread, leave for later, repeat. It’s less efficient than staring at my phone, but far more pleasant, and worth the change of pace.&lt;/p&gt;
&lt;p&gt;I’ll write more about voice mode in a future post.&lt;/p&gt;
&lt;h2&gt;Share Sheets&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; has been available on mobile web for ages. (OK, fine, months. Feels like ages.) There were really two key features that drove us to start an iOS app, features that we simply could not ship in the browser. The first was notifications; the second was the share sheet.&lt;/p&gt;
&lt;p&gt;The share sheet lets you send screenshots, files, videos, and more to Shelley on an &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VM. Sending a screenshot of a visual bug is so, so much better than describing it.&lt;/p&gt;
&lt;p&gt;My personal favorite use of the share sheet is for transcriptions.&lt;/p&gt;
&lt;p&gt;When I have a substantial new feature I want to design or a blog post I want to draft, I open up Voice Memos on iOS and talk it out, often for the better part of an hour. I have a VM configured with a Deepgram and a Voxtral integration, and a &lt;a href=&#34;https://gist.github.com/josharian/cb61a1b59716a30a21496a51e9c9b0cd&#34;&gt;rich agents.md that teaches it how to do transcriptions&lt;/a&gt;. (TL;DR: Wait for a file to appear, fan out text-to-speech to both providers, merge the results, clean up disfluencies, recognize common homophones of “&lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt;” and “VM”, trim redundant content, and email me the results, all while preserving word choice and structure.) Once I’m done recording, it’s a few taps–and zero typing–to dispatch the audio file to my transcription &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VM; the result lands later in my inbox.&lt;/p&gt;
&lt;img src=&#34;/assets/share_transcription.png&#34; alt=&#34;&#34; width=&#34;50%&#34;&gt;
&lt;p&gt;As with so many things I use &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; for, there are third-party services that do much of this, but they do it clumsily, or in a way that requires me to do a lot of pre- or post-work, or in a way that doesn’t integrate well with the rest of my cobbled-together digital life. Making it trivial to share stuff into an &lt;a href=&#34;http://exe.dev&#34;&gt;exe.dev&lt;/a&gt; VM has been a major unlock.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Connect Your ChatGPT Subscription to exe.dev</title>
    <link href="https://blog.exe.dev/chatgpt-subscription" />
    <id>https://blog.exe.dev/chatgpt-subscription</id>
    <updated>2026-07-03T00:00:00Z</updated>
    <summary>Use Shelley (and pi, and Codex) on exe.dev with the OpenAI models you already pay for.</summary>
    <content type="html">&lt;img src=&#34;/assets/chatgpt-subscription.png&#34; style=&#34;width: 100%; max-width: 640px;&#34; alt=&#34;The Edit LLM integration dialog in exe.dev, with OpenAI set to ChatGPT subscription&#34;&gt;
&lt;p&gt;We&#39;re pleased to announce that you can connect your ChatGPT subscription to exe.dev and use our coding agent Shelley with the OpenAI models you&#39;re already paying for!&lt;/p&gt;
&lt;p&gt;To enable this, go to &lt;a href=&#34;https://exe.dev/integrations&#34;&gt;exe.dev/integrations&lt;/a&gt;, click on the &amp;quot;LLM&amp;quot; integration tile, click &amp;quot;Edit&amp;quot;, choose &amp;quot;ChatGPT subscription&amp;quot; and do the authentication dance. All your VMs will then be configured to use your subscription for OpenAI models.&lt;/p&gt;
&lt;p&gt;Under the hood, this composes several exe.dev features. &lt;a href=&#34;https://exe.dev/docs/integrations&#34;&gt;Integrations&lt;/a&gt; expose additional functionality or connections to VMs with a tag-based configuration system. The reflection integration tells a VM which other integrations are attached to it, the LLM integration lets the VM make LLM requests and discover available models, and the OpenAI integration provides the authentication. When it boots up, &lt;a href=&#34;https://exe.dev/docs/shelley/intro&#34;&gt;Shelley&lt;/a&gt; offers the models available to the VM. If you prefer a terminal based agent, pi is pre-configured the same way. Codex can be configured with &lt;code&gt;exeuntu configure codex&lt;/code&gt;. As with many of our platform features, you can use the tools we&#39;ve pre-configured—and anything you build yourself can also tap the LLM integration to call models.&lt;/p&gt;
&lt;img src=&#34;/assets/chatgpt-integration-diagram.svg&#34; alt=&#34;How Shelley uses the reflection, LLM, and OpenAI integrations: it discovers integrations via the reflection integration, lists models and makes chat-completion requests through the LLM integration, and the OpenAI integration injects the upstream auth.&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Adding Features Without Interrupting Network Connections</title>
    <link href="https://blog.exe.dev/adding-features-without-interrupting-network-connections" />
    <id>https://blog.exe.dev/adding-features-without-interrupting-network-connections</id>
    <updated>2026-07-01T00:00:00Z</updated>
    <summary>How exe.dev ships updates without breaking connections.</summary>
    <content type="html">&lt;h2&gt;A busy network&lt;/h2&gt;
&lt;p&gt;People use exe.dev to build and run programs on virtual machines. For virtual machines that are serving web traffic, we &lt;a href=&#34;https://exe.dev/docs/proxy&#34;&gt;handle encryption and authentication&lt;/a&gt;. For people using their VM as a traditional computer, we &lt;a href=&#34;https://blog.exe.dev/ssh-host-header&#34;&gt;transparently support SSH access&lt;/a&gt;. We also provide terminal access to VMs via the web, and of course our popular &lt;a href=&#34;https://exe.dev/docs/shelley/intro&#34;&gt;Shelley AI coding agent&lt;/a&gt;. These features and others require exe.dev to proxy incoming connections between the broader internet and an individual VM.&lt;/p&gt;
&lt;p&gt;This network proxying isn’t trivial—we have to identify the VM the user is trying to reach, route the connection to that VM (which may be in some different region of the world), and provide basic authentication to verify that the user has access to the VM. For outgoing connections from the VM, we have to route the outgoing network connections correctly, and we provide an &lt;a href=&#34;https://exe.dev/docs/integrations&#34;&gt;increasing number of integrations&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Managing these features and adding new ones means that we regularly update the software that directs network connections, sometimes deploying multiple times a day. Of course, at the same time our users—and their users—are making and using network connections to VMs. We have to be able to deploy new software without interrupting those network connections. In this post we’ll look at how we do that.&lt;/p&gt;
&lt;h2&gt;Pipe process&lt;/h2&gt;
&lt;p&gt;The answer is to simplify the problem by handling the network connections in a separate process, known internally as &lt;em&gt;exepipe&lt;/em&gt;. The exepipe process intentionally does not implement any features. Its only job is to manage network connections. That makes it a simple program that doesn’t change very often. We can and do run it for months without redeploying it.&lt;/p&gt;
&lt;p&gt;An exepipe process takes commands from a proxy process. These commands are simple and don’t have any features or options.&lt;/p&gt;
&lt;p&gt;The simplest command is “listen on this network address, and forward any connections to this other network address.” This command is used on VM host machines to direct incoming connections on an external address to a VM address that can only be seen on the same machine.&lt;/p&gt;
&lt;p&gt;Another command is “take these two network connections, and copy data back and forth between them.” This is used by the proxy. The proxy will accept an incoming connection, handle authentication, decide which VM the user is trying to reach, and open a connection to that VM. When both connections are up and running, the proxy will direct exepipe to copy data between the connections.&lt;/p&gt;
&lt;p&gt;This uses a handy and slightly obscure socket feature: &lt;a href=&#34;https://man7.org/linux/man-pages/man7/unix.7.html&#34;&gt;Unix socket ancillary data&lt;/a&gt;. When using a Unix domain socket, you can send ancillary data which can include, among other things, file descriptors. The receiving process gets a new file descriptor that refers to the same open file description as the original process. This file description can be a network socket. This effectively duplicates a network socket from one process to another.&lt;/p&gt;
&lt;p&gt;For both of these commands, the exepipe process winds up copying data between network connections. Fortunately on Linux this can be done efficiently using a pair of &lt;a href=&#34;https://man7.org/linux/man-pages/man2/splice.2.html&#34;&gt;&lt;code&gt;splice&lt;/code&gt;&lt;/a&gt; calls over a pipe.&lt;/p&gt;
&lt;p&gt;Since exepipe is rarely restarted, this copying will last as long as it needs to.&lt;/p&gt;
&lt;p&gt;There are of course many ways to copy data between network connections, such as the &lt;a href=&#34;https://man7.org/linux/man-pages/man1/socat.1.html&#34;&gt;socat program&lt;/a&gt;. That, however, requires a separate socat program per connection and a lot of state tracking. Using a single exepipe server is a more efficient use of system resources.&lt;/p&gt;
&lt;h2&gt;SSH copying&lt;/h2&gt;
&lt;p&gt;Handling SSH connections is similar, except that forwarding one SSH connection to another SSH connection is more complicated than forwarding a simple TCP connection. The SSH protocol is packet-oriented, with separate communication channels, and the ability for the SSH client to query the SSH server in various ways. The exepipe process has to forward these channels and queries back and forth over two SSH connections.&lt;/p&gt;
&lt;h2&gt;Restarting the pipe process&lt;/h2&gt;
&lt;p&gt;Of course, sometimes we do need to change exepipe.&lt;/p&gt;
&lt;p&gt;When we redeploy exepipe, we don’t want to break any of the connections that the existing instance is managing. So, rather than restart exepipe, we start a new exepipe and leave the old one running.&lt;/p&gt;
&lt;p&gt;The new exepipe will contact the old exepipe and tell it to transfer any listening sockets, including the socket used to receive new commands from the proxy. The listening sockets will be handed over using Unix socket ancillary data. The old exepipe will then do nothing but keep copying data between sockets that are already open. When all of those socket connections are closed, the old exepipe has nothing left to do and it will quietly exit.&lt;/p&gt;
&lt;p&gt;This work is all in the service of supporting exe.dev users. We handle the details of the network to present a simple and seamless interface, using implementation complexity to provide user simplicity.&lt;/p&gt;
</content>
    <author>
      <name>Ian Lance Taylor</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Building the exe.dev iOS App</title>
    <link href="https://blog.exe.dev/ios-development" />
    <id>https://blog.exe.dev/ios-development</id>
    <updated>2026-06-23T00:00:00Z</updated>
    <summary>the software workshop behind the iOS app</summary>
    <content type="html">&lt;p&gt;If you haven&#39;t checked out our app yet, it&#39;s in the &lt;a href=&#34;https://apps.apple.com/us/app/exe-dev/id6759881448&#34;&gt;App Store&lt;/a&gt;. We &lt;a href=&#34;/ios&#34;&gt;blogged about it&lt;/a&gt; the other day.&lt;/p&gt;
&lt;p&gt;Once we decided in one of our Tuesday in-person meetings to build our iOS app, my first stop was the Stonestown Mall Apple Store, to buy the best Mac Mini I could find. (The choices were slim!) From my experience building on the web with &lt;a href=&#34;https://exe.dev/shelley&#34;&gt;Shelley&lt;/a&gt;, I knew that I needed to set up a &amp;quot;software workshop&amp;quot; (I hesitate to call this one a factory) where the agent had access to the iOS simulator and the capacity to screenshot it.&lt;/p&gt;
&lt;p&gt;My building blocks were as follows:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;An exe.dev VM (&amp;quot;the proxy&amp;quot;) where I could access Shelley (the coding agent) on https://proxy-vm.shelley.exe.xyz/&lt;/li&gt;
&lt;li&gt;Shelley, running on the Mac mini&lt;/li&gt;
&lt;li&gt;SSH -R forwarding, such that port 9999 on the proxy VM connected back to Shelley on the Mac. Since exe.dev VMs are on the Internet behind an auth proxy, this lets me access my agent from my other computers and my phone.&lt;/li&gt;
&lt;li&gt;XCode and the iOS simulator&lt;/li&gt;
&lt;li&gt;The entertainingly-named &lt;a href=&#34;https://www.xcodebuildmcp.com&#34;&gt;xcodebuildmcp-cli&lt;/a&gt; and a quick AGENTS.md that told Shelley about it. Shelley calls this using the bash tool. There&#39;s no MCP here; the CLI was more than enough.&lt;/li&gt;
&lt;li&gt;A USB cable to install the app onto my phone once, so that future builds could be delivered over the air. (If I were to do it over again, I&#39;d investigate &lt;a href=&#34;https://docs.fastlane.tools/actions/match/&#34;&gt;Fastlane match&lt;/a&gt;which manages these certs.)&lt;/li&gt;
&lt;li&gt;A vibe-coded over-the-air (OTA) server which serves a &lt;code&gt;manifest.plist&lt;/code&gt; on a (required) TLS connection. This OTA server builds my tree whenever it changes, and serves a button to install the tip onto my phone over the air. Cookies aren&#39;t sent once you go into the download flow, so if you run this on exe.dev, you need to make the server public, implement auth for the index page using &lt;a href=&#34;https://exe.dev/docs/login-with-exe&#34;&gt;&amp;quot;Login with exe&amp;quot;&lt;/a&gt; and serve the relevant downloads obscure but unprotected. (Or you can use Tailscale if your phone and Mac are on the same Tailscale network.)&lt;/li&gt;
&lt;li&gt;If you don&#39;t want to dedicate a Mac to it, you can use a Tart VM, and that&#39;s pretty smooth too. I use a Tart VM for the CI builder. We continuously deploy test builds into TestFlight Employee builds from main, because, as Dani Rojas didn&#39;t say in Ted Lasso, &amp;quot;CD is Life.&amp;quot;&lt;/li&gt;
&lt;/ul&gt;
&lt;img src=&#34;https://boldsoftware.github.io/public_html/ios-development.svg&#34; alt=&#34;The exe.dev iOS development workshop&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
&lt;p&gt;Once I could ask the agent for a change from my phone, using the app (or Shelley on mobile web), and download the subsequent build to try it, the workshop was complete: I could now use the app, identify something that&#39;s bothering me, and tee it up for the agent. Iteration, for the win.&lt;/p&gt;
&lt;p&gt;A few more vignettes from app development:&lt;/p&gt;
&lt;p&gt;The app has to synchronize with all the Shelley agents. Somehow, partial synchronization of a sqlite database (what&#39;s called &amp;quot;incremental view maintenance&amp;quot; in the literature) is very much not a cookie-cutter solved problem. I used two approaches. First, for the conversation list, every time there&#39;s a sqlite commit in Shelley, Shelley re-computes the &amp;quot;active conversations list,&amp;quot; compares it to the previous one, and sends a jsondiff over the connected SSE stream to the app. Because the data is small (it&#39;s bounded to hundreds of conversations) and this only happens when you&#39;re active, this is fast enough. This allows the client keep an up to date conversation list view (per VM). Within a conversation, Shelley&#39;s messages table is an append-only log with dense sequence ids. This lets the client cache messages 1-17, and, when the client realizes that we&#39;re at 20, it can fetch 18-20 and stay up to date. Shelley&#39;s web UI uses the same protocols using encrypted IndexedDB as a cache. Image attachments to LLM calls get removed and fetched asynchronously, too. (The next optimization would be to remove tool call outputs as well.) I ended up porting this &amp;quot;ShelleyKit&amp;quot; library to vanilla Swift, so that I could run its tests on Linux easily.&lt;/p&gt;
&lt;p&gt;As you&#39;d expect, during development, things were often slow. I used MetricsKit to send logs back to our backend, where I would analyze them with Clickhouse. I also built debug overlays on the conversation view that showed me what was coming over the stream, and what we were redrawing, and so on. The debug build also has a built-in profiler that shows a flamegraph of what&#39;s going on. With a little bit of iteration, I&#39;m reasonably happy with the performance of the app, though there is always much more to do.&lt;/p&gt;
&lt;video controls=&#34;&#34; playsinline=&#34;&#34; preload=&#34;metadata&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
    &lt;source src=&#34;https://boldsoftware.github.io/public_html/ios-development-profiler.mp4&#34; type=&#34;video/mp4&#34;&gt;    Your browser does not support the video tag.
  &lt;/video&gt;
&lt;p&gt;For the terminal, we&#39;d already built a web-based terminal with persistence. That works by running your login shell under &lt;code&gt;dtach&lt;/code&gt; and connecting to the dtach unix socket using SSH from our proxy servers. The web-based terminal uses websockets to connect to that. This provides persistent sessions that survive browser reloads, Wifi interruptions, and so on. Our iOS terminal uses the same mechanism.&lt;/p&gt;
&lt;p&gt;When I was collecting e-mails from our users on Discord for TestFlight, I started, from habit, clicking on a Google Form. Then, I thought to myself, &amp;quot;what am I doing?!?!&amp;quot; and spun up a VM and vibe-coded a registration app. In the end, this app managed not just the TestFlight intake, but also helped me invite people to TestFlight, and kept track of builds.&lt;/p&gt;
&lt;p&gt;The following shape of a prompt was valuable for finding some issues ahead of the App Review cycle.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Look through the apple iOS app guidelines as well as our iOS app systematically, using subagents. What needs to be fixed? https://developer.apple.com/app-store/review/guidelines/&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;We hope you give the iOS app a whirl!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Announcing the exe.dev iOS App</title>
    <link href="https://blog.exe.dev/ios" />
    <id>https://blog.exe.dev/ios</id>
    <updated>2026-06-15T00:00:00Z</updated>
    <summary>The exe.dev iOS app is in the App Store. Here&#39;s why we built it.</summary>
    <content type="html">&lt;p&gt;We&#39;re delighted to announce that exe.dev has an iOS app now in the App Store. There&#39;s a lot to write about how we built it, but today let&#39;s talk about the why. After all, the &lt;code&gt;exe.dev&lt;/code&gt; dashboard and Shelley already work on mobile browsers.&lt;/p&gt;
&lt;p&gt;They say the best camera is the one you have with you. The best terminal is the one you have with you too. We couldn&#39;t build the following features without building an app, so an app it is:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Notifications.&lt;/strong&gt; Agentic conversations are high-latency, and it&#39;s useful to be notified when it&#39;s your turn. Nothing on iOS comes close to the native notifications experience. Of course, we built this with an exe integration: other software you build on your VM can use the same &lt;code&gt;notify.int.exe.xyz&lt;/code&gt;integration to ping your phone.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Share sheet.&lt;/strong&gt; Many prompts begin with a screenshot. Take one, click share, and click on exe.dev to start an agentic conversation. Whether it&#39;s a UI element that&#39;s out of alignment or a Slack message you received, the share sheet speeds up &amp;quot;time to agent is working on it.&amp;quot;&lt;/p&gt;
&lt;img src=&#34;https://boldsoftware.github.io/public_html/ios-screenshot.png&#34; alt=&#34;exe.dev in the iOS share sheet&#34; style=&#34;max-width: 320px; width: 100%; height: auto;&#34;&gt;
&lt;p&gt;&lt;strong&gt;Voice.&lt;/strong&gt; We built a voice mode that can harness the power of having real computing resources available to you.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;SSH.&lt;/strong&gt; There are several excellent SSH clients already available for SSH, but the process of creating a key and registering it with exe.dev is cumbersome. We do not yet support mosh (it&#39;s on the roadmap!) which makes roaming prone to dropping connections. Having a terminal client in our app side-steps that. We have happy users that have persistent Claude Code sessions in their terminals. Paste works, by the way.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Multiplexing Shelley.&lt;/strong&gt; One of our taglines is &amp;quot;a VM for every idea.&amp;quot; Instead of walking through each VM in turn to find unfinished business, the iOS app provides a centralized place.&lt;/p&gt;
&lt;p&gt;I want to thank our TestFlight users for providing valuable feedback while suffering through many a crash!&lt;/p&gt;
&lt;p&gt;The app is in the &lt;a href=&#34;https://apps.apple.com/us/app/exe-dev/id6759881448&#34;&gt;App Store&lt;/a&gt;. Give it a whirl. &lt;a href=&#34;https://exe.dev/docs/getting-help&#34;&gt;Send us feedback&lt;/a&gt; via Discord or support@exe.dev.&lt;/p&gt;
&lt;video controls=&#34;&#34; playsinline=&#34;&#34; preload=&#34;metadata&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
    &lt;source src=&#34;https://boldsoftware.github.io/public_html/ios-intro-1.mp4&#34; type=&#34;video/mp4&#34;&gt;    Your browser does not support the video tag.
  &lt;/video&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Sharing Is Caring</title>
    <link href="https://blog.exe.dev/sharing" />
    <id>https://blog.exe.dev/sharing</id>
    <updated>2026-06-10T00:00:00Z</updated>
    <summary>At exe.dev, sharing a web app you built is as easy as forwarding an email.</summary>
    <content type="html">&lt;p&gt;Today&#39;s quiz is to deploy a server-rendered hello world app (&lt;code&gt;python3 -mhttp.server&lt;/code&gt; fine for these purposes, though I used Go below), publically visible, on your cloud of choice. On your marks, get set, GO!&lt;/p&gt;
&lt;div class=&#34;asciinema-embed&#34; id=&#34;sharing-cast&#34;&gt;&lt;/div&gt;
&lt;script src=&#34;/assets/asciinema-player.min.js&#34;&gt;&lt;/script&gt;
&lt;script&gt;
  (function () {
    var darkMedia = window.matchMedia(&#34;(prefers-color-scheme: dark)&#34;);
    var target = document.getElementById(&#34;sharing-cast&#34;);
    var player = null;
    function render() {
      if (player &amp;&amp; player.dispose) { player.dispose(); }
      target.innerHTML = &#34;&#34;;
      var opts = {
        autoPlay: true,
        loop: false,
        cols: 80,
        rows: 25,
        idleTimeLimit: 2
      };
      if (darkMedia.matches) { opts.theme = &#34;asciinema&#34;; }
      player = AsciinemaPlayer.create(
        &#34;/assets/2026-06-10-sharing.cast&#34;,
        target,
        opts
      );
    }
    render();
    darkMedia.addEventListener(&#34;change&#34;, render);
  })();
&lt;/script&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ ssh exe.dev new --name mr-rogers
$ ssh exe.dev share set-public mr-rogers
$ ssh mr-rogers.exe.xyz
# on that machine:
$ cat &amp;gt; main.go
package main

import (
        &amp;#34;fmt&amp;#34;
        &amp;#34;net/http&amp;#34;
)

func main() {
        http.HandleFunc(&amp;#34;/&amp;#34;, func(w http.ResponseWriter, r *http.Request) {
                fmt.Fprintln(w, &amp;#34;hello world&amp;#34;)
        })
        http.ListenAndServe(&amp;#34;:8000&amp;#34;, nil)
}
^D
$ go run main.go  # maybe in a tmux

# back on your laptop, open https://mr-rogers.exe.xyz/
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;At exe.dev, our goal is to make sharing a web app that you built as easy as forwarding an e-mail. You saw the command-line approach above; there&#39;s an equivalent web-based flow as well.&lt;/p&gt;
&lt;p&gt;If you don&#39;t want to share with the whole world, but only some friends, the &lt;a href=&#34;https://exe.dev/docs/cli-share&#34;&gt;share command&lt;/a&gt; also takes e-mail addresses, and your users can log into your site.&lt;/p&gt;
&lt;p&gt;If you use exe.dev on a team, the sharing hierarchy is richer in that you can also share SSH access to your VM with a team member. The full hierarchy of sharing is:&lt;/p&gt;
&lt;table style=&#34;min-width: 75px;&#34;&gt;
&lt;colgroup&gt;&lt;col style=&#34;min-width: 25px;&#34;&gt;&lt;col style=&#34;min-width: 25px;&#34;&gt;&lt;col style=&#34;min-width: 25px;&#34;&gt;&lt;/colgroup&gt;&lt;tbody&gt;&lt;tr&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;&lt;/p&gt;&lt;/th&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Individual Accounts&lt;/p&gt;&lt;/th&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Team Accounts&lt;/p&gt;&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Administrative&lt;br&gt;(e.g., removing the VM)&lt;/p&gt;&lt;/th&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Only owner&lt;/p&gt;&lt;/td&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Owner, and, indirectly, team administrators&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;SSH access&lt;br&gt;(and agent access)&lt;/p&gt;&lt;/th&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Only owner&lt;/p&gt;&lt;/td&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Owner, or can be shared with team&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;th colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Single web port&lt;/p&gt;&lt;/th&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Can be shared publicly, or with individual e-mail addresses.&lt;/p&gt;&lt;/td&gt;&lt;td colspan=&#34;1&#34; rowspan=&#34;1&#34;&gt;&lt;p&gt;Can be shared publicly, with a team, or with individual e-mail addresses.&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;
&lt;/table&gt;</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Replace Your CI With a Merge Queue</title>
    <link href="https://blog.exe.dev/replace-your-ci" />
    <id>https://blog.exe.dev/replace-your-ci</id>
    <updated>2026-06-07T00:00:00Z</updated>
    <summary>Agent development means after-the-fact CI no longer works.</summary>
    <content type="html">&lt;p&gt;The standard in CI today is tests run in the cloud after a commit has been merged. They serve as a double-check for an engineer: did you forget to test some part of your code that you changed?&lt;/p&gt;
&lt;p&gt;CI works for humans. The reason is our long-term understanding of a codebase and its evolution. Engineers new to a codebase know they are new and take more care (or get automated emails telling them they broke CI). Humans familiar with the codebase know implicitly what they need to be testing as they work.&lt;/p&gt;
&lt;p&gt;The automated email from CI works because it is rare, because we all develop at human speed and breaking HEAD is OK for a little while. Some teams try auto-revert on CI breakage. This works, but you lose a lot of the value of after-the-fact testing in continual retries. Still, it works. It is better than nightly builds and binary searching your way to the culprit.&lt;/p&gt;
&lt;p&gt;It does not work for agents. At least not as of June 2026.&lt;/p&gt;
&lt;p&gt;There are two problems here. The first is that agents are always new to a codebase. They don’t have all the implicit knowledge of the codebase expert, and so they regress parts of the project they have not paid attention to &lt;em&gt;all the time&lt;/em&gt;. It is excruciating developing with an agent and CI. Your agent needs to run all the tests as it is developing to make sure it understands the environment.&lt;/p&gt;
&lt;p&gt;The second problem is the agent context window is dead and gone by the time the poor human driving it is stuck with an automated email saying they broke CI. Your agent should have been quietly solving that problem before making it other people’s problem. It has all the time in the world as long as it is not in anyone’s way. Let the computer drive the computer.&lt;/p&gt;
&lt;p&gt;So you need to get your org into a place where agents can run all the tests all the time. There is an easy way to do this. Replace your CI with a merge queue.&lt;/p&gt;
&lt;h2&gt;Merge queue&lt;/h2&gt;
&lt;p&gt;A merge queue is a script you run to push to &lt;code&gt;origin/main&lt;/code&gt; (instead of using a PR UI like we did back in the GitHub, all-human days).&lt;/p&gt;
&lt;p&gt;It is very important you run &lt;strong&gt;all&lt;/strong&gt; the tests in the merge queue. Do not have &amp;quot;slow&amp;quot; tests you run daily. In the age of agents, those tests will be broken &lt;em&gt;every day&lt;/em&gt;. Someone will spend hours every day chasing after other people&#39;s agents. This is not a role anyone on the team wants. It turns out the only thing worse than cleanup up after someone else is cleaning up after someone eles&#39;s robot.&lt;/p&gt;
&lt;p&gt;After you have a merge queue that works, create a second command to run the merge queue, minus the actual merge. Give it to your agents.&lt;/p&gt;
&lt;p&gt;This ensures:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;The active context window can run the tests and fix the bugs before inflicting them on other people.&lt;/li&gt;
&lt;li&gt;No one, neither human nor machine, breaks the build.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Back when we were all human, and CI was slow, you could make arguments for CI instead of merge queues. Those arguments depended on tests being too slow to put in the merge path, and that will not stand in 2026, tests must be fast to use agents. Now it is impossible. With agents, CI is useless, the merge queue is vastly superior.&lt;/p&gt;
&lt;p&gt;You will need expensive computers to power your merge queue. It is worth it.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Dev, Test, Prod: Choose One, Two, or Three</title>
    <link href="https://blog.exe.dev/dev-test-prod" />
    <id>https://blog.exe.dev/dev-test-prod</id>
    <updated>2026-05-04T16:00:00Z</updated>
    <summary>You can build, test, and deploy on exe.dev.</summary>
    <content type="html">&lt;img src=&#34;/assets/devprodtest-venn.svg&#34; alt=&#34;Venn diagram showing Dev, Test, and Prod overlapping with exe.dev in the center&#34; width=&#34;100%&#34;/&gt;
&lt;p&gt;Industry-wide, we often develop our software in three distinct environments.
Perhaps your laptop is a Mac; your CI system is hosted GitHub Actions, and your
prod is k8s.&lt;/p&gt;
&lt;h1&gt;Three-in-One&lt;/h1&gt;
&lt;p&gt;For some use cases, you need not bother with the complexity; use one exe.dev vm
for all three. A blog, a dashboard, a link shortener, a bot, and so on: these
work well with the environments collapsed. Add features by asking Shelley to do
so. Set up continuous deployment by asking Shelley to poll every hour. Use git
for a backup if it calls for it. Voila!&lt;/p&gt;
&lt;div style=&#34;position: relative; overflow: hidden; border: 1px solid #e5e7eb; border-radius: 8px; padding: 1rem 6rem 1rem 1rem; margin: 1rem 0;&#34;&gt;
  &lt;p style=&#34;margin: 0;&#34;&gt;Our internal tools sport an &#34;Edit with Shelley&#34; ribbon.
  They either point straight to the &#34;vm.shelley.exe.xyz&#34; domain, or link
  to exe.dev/new with a pre-filled prompt and pre-filled tags, just
  like the link here.&lt;/p&gt;
  &lt;a href=&#34;https://exe.dev/new?prompt=Clone%20github-thing.int.exe.xyz%20and%20do:...&amp;tags=github-thing&#34; target=&#34;_blank&#34; rel=&#34;noopener noreferrer&#34; style=&#34;position: absolute; top: 30px; right: -32px; background: #fbbf24; color: #78350f; padding: 5px 44px; font-size: 11px; font-weight: 600; transform: rotate(45deg); box-shadow: 0 1px 3px rgba(0,0,0,0.15); text-align: center; letter-spacing: 0.2px; white-space: nowrap; font-family: -apple-system, BlinkMacSystemFont, &#39;Segoe UI&#39;, sans-serif; text-decoration: none;&#34;&gt;Edit with Shelley&lt;/a&gt;
&lt;/div&gt;
&lt;h1&gt;Just Dev&lt;/h1&gt;
&lt;p&gt;Use an exe.dev vm (or many) to work on your software. Set up the GitHub
integration (&lt;a href=&#34;https://exe.dev/docs/integrations-github&#34;&gt;docs&lt;/a&gt;) to make cloning easy. Some people work
serially. Some people work using multiple worktrees on one vm. Some people have
one vm per task or project. Clone your VMs using ‘cp’ or configure them using
setup scripts.&lt;/p&gt;
&lt;p&gt;Using remote VMs opens up the convenience of mobile, opportunities for sharing,
not to mention isolation from your other projects.&lt;/p&gt;
&lt;img src=&#34;/assets/devprodtest-seesaw.svg&#34; alt=&#34;Seesaw balancing customization against convenience&#34; width=&#34;100%&#34;/&gt;
&lt;p&gt;Why now? Many, many companies have tried remote development before. There is
an entire graveyard of failed startups in this space. The big difference is
agents. If your development is increasingly chat-based, the old arguments about
getting your environment and dot-rc files just right fade away. The convenience
of starting a task from your phone overwhelms the decades-old bashrc file and
finely crafted PS1. As a bonus, you get the ability to share with your co-workers.
Pull requests are so yesterday; send them a link to a working demo instead.&lt;/p&gt;
&lt;h1&gt;Just Test&lt;/h1&gt;
&lt;p&gt;Exe.dev VMs are a great place to riff on an idea. Perhaps you want to explore a
particular open source project. Or you want to do some data analysis and share
it with your co-workers? Or prototype your next idea? Or find your flakes by
running your tests over and over again. Or let loose Shelley, our agent, on
your app with its built-in browser? Or send off a security review. Or even
just run a GitHub Actions runner.&lt;/p&gt;
&lt;p&gt;Because you pick what access you want to give your VMs, and because they’re
&lt;a href=&#34;https://exe.dev/docs/serverful&#34;&gt;persistent&lt;/a&gt;, exe.dev VMs are great
places to test stuff out.&lt;/p&gt;
&lt;h1&gt;Just Prod&lt;/h1&gt;
&lt;p&gt;You can host real, production software in exe. We support custom domains with a bit of DNS
configuration (&lt;a href=&#34;https://exe.dev/docs/cnames&#34;&gt;docs&lt;/a&gt;).&lt;/p&gt;
&lt;p&gt;If you’re incredulous that this is a good idea, the entirety of Stack Overflow
ran on &lt;a href=&#34;https://nickcraver.com/blog/2016/02/17/stack-overflow-the-architecture-2016-edition/&#34;&gt;just a few
machines&lt;/a&gt;.
Reach out to us if you want to enlarge your VM as far as modern hardware can
go.&lt;/p&gt;
&lt;h1&gt;Private, Internal, or Public&lt;/h1&gt;
&lt;p&gt;Once you build it, you&#39;ll want to share it. You can keep it to yourself,
and that&#39;s the default. Or you can share it with your team or with share links.
Or you can share it publically. Sharing a VM&#39;s website is as easy as sharing
any other online doc.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Series A for exe.dev</title>
    <link href="https://blog.exe.dev/series-a" />
    <id>https://blog.exe.dev/series-a</id>
    <updated>2026-04-22T00:00:00Z</updated>
    <summary>exe.dev has raised a Series A to build a development-focused cloud</summary>
    <content type="html">&lt;p&gt;We have raised a Series A, for a total of $35m in funding.
We are using it to build a new generation of cloud infrastructure.
Major investors are Amplify, CRV, and HeavyBit.&lt;/p&gt;
&lt;p&gt;Call it a cloud for developers.&lt;/p&gt;
&lt;p&gt;Why do we need new infrastructure primitives and a new cloud now?
Agents. Lower barriers to entry mean there are going to be more
developers, and each of us is going to write more programs.
Software needs a home; exe.dev is a good home for software.&lt;/p&gt;
&lt;p&gt;Many companies are approaching the question of next generation
infrastructure as “What do agents need?” We believe this is the
wrong question.
Agents are trained on how developers work.
They want exactly what we want.
Full computers, understandable and stable building blocks, familiar
systems wherever possible.
You can see that in our approach.
The moment you start with exe.dev, you use SSH. You know it.&lt;/p&gt;
&lt;p&gt;We are building a cloud that makes sense for the current and future
state of software development.
One that includes the features needed for fast, secure development out
of the box.
A cloud developers actually enjoy using.
We want to revitalize the spirit of projects like early Heroku
(though our technology is very different) and ship features that bring
you joy.
That is why our servers have HTTPS by default, and are private by
default, and are easy to share with a link.
It is why our pricing for individual developers is simple: pay a flat
rate, run as many computers as you need with the CPU and memory
purchased.
And it is why we have a simple web-based agent in the default Ubuntu
image with credits included in the default plan.
Sometimes you just need an agent.&lt;/p&gt;
&lt;p&gt;We have a lot of work to do! There is a lot to build.
To get these primitives right we are not building on top of existing
clouds; we are working with our own machines in data centers.
We have written our own global load balancer. We do our own DNS.
We have to strip away all the layers and go back to the actual
computers to ship a cloud developers actually like. Traditional Cloud
1.0 companies sell you a VM with a default of 3000 IOPS, while your
laptop has 500k.
Getting the defaults right (and the cost of those defaults right)
requires careful thinking through the stack. Hence the Series A: we
have some computers to buy.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Some Secret Management Belongs in Your HTTP Proxy</title>
    <link href="https://blog.exe.dev/http-proxy-secrets" />
    <id>https://blog.exe.dev/http-proxy-secrets</id>
    <updated>2026-04-18T00:00:00Z</updated>
    <summary>do third-party integrations via HTTP header management</summary>
    <content type="html">&lt;p&gt;Secrets management is a pain.&lt;/p&gt;
&lt;p&gt;Larger organizations commit to centralizing secrets management in a service. When done well, these services solve a lot of issues around secrets, at the cost of creating a lot of ops overhead (which is why they are limited to larger organizations) and engineering complexity. Smaller organizations have, until now, lived with the pain. But the pain has become far more significant with agents.&lt;/p&gt;
&lt;p&gt;Agents fuss when you directly hand them an API key. It usually works, and if you make it a rapidly revocable key that you disable after the session, you mitigate the risks. But some models (you know which ones) freak out on seeing the secret, and refuse to do anything now that the key is “exposed.” Models that are not so ridiculous about API keys will write the key to inter-session memory, pulling it out in another session and burning precious context window trying to use a revoked key. All of which assumes you go to the effort of constantly generating keys.&lt;/p&gt;
&lt;p&gt;Like so many problems getting attention right now, this looks like a problem created by agents. But the problem was always there. API keys are convenient but too powerful. Holding one does not just grant you the ability to make API calls, it grants you the power to &lt;em&gt;give others the ability&lt;/em&gt; to make API calls (by sending them the key). No software I write in production that has an /etc/defaults file full of env vars containing API keys needs that power. We have always just been careful about how we write programs to not exfil keys. Never careful enough, because many security flaws in such an app now let the attacker walk off the keys and give them a window to do nastiness from wherever they like, until we realize and start manually rotating them.&lt;/p&gt;
&lt;p&gt;Attempts to automate key rotation to close this hole have mixed success. Our industry does use OAuth in some places, and sometimes OAuth is configured to rotate keys. But services still ship API keys, because they are easy for users. (OAuth, while simple in theory, is always painfully complex to use.) Some services give us the worst of all worlds, like GitHub encouraging personal access tokens with 90-day expiry windows. Just long enough for you to forget about them and your internal service to break mysteriously while you are on vacation.&lt;/p&gt;
&lt;p&gt;Inter-server OAuth as commonly practiced today also does not help with agents, as creation is usually designed to have some human intervention via a web browser cookie in a way deliberately designed to be hard to automate. I do not think I have ever used a service that gave me an OAUTH_CLIENT_SECRET via an API. So it’s fine (if complex and painful) for traditional services, but your agent is not doing that.&lt;/p&gt;
&lt;p&gt;So in practice, what can we do today to solve this?&lt;/p&gt;
&lt;p&gt;We can use an HTTP proxy that injects headers.&lt;/p&gt;
&lt;h2&gt;Many secrets are HTTP headers&lt;/h2&gt;
&lt;p&gt;Many APIs talk HTTP. They usually ship an HTTP header, either a basic auth header or their own. Here is, for example, Stripe’s:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl https://api.stripe.com/v1/customers \
  -u &amp;#34;sk_test_BQokikJOvBiI2HlWgH4olfQ2:&amp;#34; \
  -d &amp;#34;name=Jenny Rosen&amp;#34; \
  --data-urlencode &amp;#34;email=jennyrosen@example.com&amp;#34;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;So instead of an /etc/defaults file with your sk_test key, if you have an HTTP proxy managing secrets you can do this:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl https://stripe.int.exe.xyz/v1/customers \
  -d &amp;#34;name=Jenny Rosen&amp;#34; \
  --data-urlencode &amp;#34;email=jennyrosen@example.com&amp;#34;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Where the server in the URL has been changed to another internal service you run. And the key has been removed! What grants your server, and your agents, the ability to use the secret is their ability to reach your secrets HTTP proxy.&lt;/p&gt;
&lt;img src=&#34;/assets/secrets-proxy.svg&#34; alt=&#34;Secrets HTTP proxy topology&#34; style=&#34;max-width: 100%;&#34;&gt;
&lt;p&gt;This covers, amazingly, almost all secrets.&lt;/p&gt;
&lt;p&gt;A proxy like this is part of machinery provided by complex secrets management products. What is interesting is that it is one of the easier parts of secrets management, and delivers a large amount of the value.&lt;/p&gt;
&lt;h2&gt;&lt;em&gt;Integrations&lt;/em&gt; in exe.dev&lt;/h2&gt;
&lt;p&gt;The final piece of the puzzle is: why do you need to write and manage an HTTP proxy? Your cloud should do it for you. So we built Integrations into exe.dev to do this. Assign an integration to a tag, tag the VMs you want to have access, done. Clone your VM, you get a fresh space to work with agents and your integrations are automatically present.&lt;/p&gt;
&lt;img src=&#34;/assets/exe-stripe-http.png&#34; style=&#34;width: 600px; height: 600px;&#34; alt=&#34;A screenshot of setting up an HTTP integration in exe.dev&#34;&gt;
&lt;p&gt;For GitHub, we did something special, and built a GitHub App to manage the OAuth for you. No need for manual rotation of keys. We intend to build a lot more integrations soon.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw and Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Closer Compute 🇺🇸 🇬🇧 🇯🇵 🇩🇪 🇦🇺</title>
    <link href="https://blog.exe.dev/regions" />
    <id>https://blog.exe.dev/regions</id>
    <updated>2026-04-11T00:00:00Z</updated>
    <summary>exe.dev now runs machines around the world, so your machine is close to you.</summary>
    <content type="html">&lt;p&gt;When you use a computer for development, latency matters. Even if you typically hang out in a remote-connected editor over sshfs (like Visual Studio), sometimes you need to debug a pesky systemd service or search for a config file. There is nothing worse than being knee-deep in a hard problem, and then watching your terminal stutter.&lt;/p&gt;
&lt;p&gt;There is no software fix for this. Latency to your remote-host computer is limited by the speed of light. So we have to solve the problem physically and move the servers closer to you. That is why exe.dev now runs machines in regions around the world:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;🇺🇸 &lt;strong&gt;LAX&lt;/strong&gt; — Los Angeles, USA&lt;/li&gt;
&lt;li&gt;🇺🇸 &lt;strong&gt;NYC&lt;/strong&gt; — New York, USA&lt;/li&gt;
&lt;li&gt;🇺🇸 &lt;strong&gt;DAL&lt;/strong&gt; — Dallas, USA&lt;/li&gt;
&lt;li&gt;🇩🇪 &lt;strong&gt;FRA&lt;/strong&gt; — Frankfurt, Germany&lt;/li&gt;
&lt;li&gt;🇬🇧 &lt;strong&gt;LON&lt;/strong&gt; — London, UK&lt;/li&gt;
&lt;li&gt;🇯🇵 &lt;strong&gt;TYO&lt;/strong&gt; — Tokyo, Japan&lt;/li&gt;
&lt;li&gt;🇦🇺 &lt;strong&gt;SYD&lt;/strong&gt; — Sydney, Australia&lt;/li&gt;
&lt;li&gt;🇸🇬 &lt;strong&gt;SGP&lt;/strong&gt; — Singapore&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;We want exe.dev to be the best place to do development, and that means meeting you where you are, both in software and real life.&lt;/p&gt;
&lt;p&gt;More regions will be coming online throughout the year.&lt;/p&gt;
&lt;h2&gt;Setting your region&lt;/h2&gt;
&lt;p&gt;Your account&#39;s region determines where new VMs are created. You can change it in your &lt;a href=&#34;https://exe.dev/account&#34;&gt;account settings&lt;/a&gt;, or from the exe.dev lobby:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;ssh exe.dev set-region lon
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;New VMs you create will be hosted in that region from then on.&lt;/p&gt;
&lt;h2&gt;Moving existing VMs&lt;/h2&gt;
&lt;p&gt;Already have VMs in a region that&#39;s far away? Write to &lt;a href=&#34;mailto:support@exe.dev&#34;&gt;support@exe.dev&lt;/a&gt; and we&#39;ll move them for you.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>A Transparent UI Pattern</title>
    <link href="https://blog.exe.dev/a-simple-ui-pattern" />
    <id>https://blog.exe.dev/a-simple-ui-pattern</id>
    <updated>2026-04-02T15:00:00Z</updated>
    <summary>exe.dev&#39;s UI shows you the command it&#39;s running, so you always know how to script it.</summary>
    <content type="html">&lt;img src=&#34;https://boldsoftware.github.io/public_html/share-button.gif&#34; alt=&#34;The exe.dev UI showing the command being run&#34; style=&#34;max-width: 100%; height: auto;&#34; /&gt;
&lt;p&gt;exe.dev has one API: it&#39;s the command you would write in the exe.dev lobby. For
example, &lt;code&gt;share add island-anchor &amp;quot;philip&#43;demo2@bold.dev&amp;quot;&lt;/code&gt; shares the HTTP
server for the VM island-anchor to that e-mail address. (We believe sharing a
web app should be as simple as sharing a document!) You can do that very same
command over our HTTP API. Our UI tells you what command it&#39;s running, right down to
the quoting.&lt;/p&gt;
&lt;p&gt;We do this for two reasons:&lt;/p&gt;
&lt;p&gt;First, it teaches our users that everything they&#39;re doing in the UI, they (and
their agents!) can do in the CLI. We know our users are going to want to script.&lt;/p&gt;
&lt;p&gt;Second, it keeps us honest. The UI can&#39;t cheat. If the system doesn&#39;t expose
the right API knobs, we find out immediately because the UI uses the same
interface.&lt;/p&gt;
&lt;p&gt;We like this pattern. We hope you do too.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Prompt Engineering Is Dead, but Claude Still Tries</title>
    <link href="https://blog.exe.dev/prompt-engineering-is-dead" />
    <id>https://blog.exe.dev/prompt-engineering-is-dead</id>
    <updated>2026-03-31T00:00:00Z</updated>
    <summary>Agents have good judgment now. Delegation beats micromanagement.</summary>
    <content type="html">&lt;p&gt;A year ago, Claude was better at prompting than I was. Not any more.&lt;/p&gt;
&lt;p&gt;Coding agents have gotten dramatically better. Good prompting used to require carefully calibrated instructions and harnesses. Now a good prompt includes goals, context, and maybe some preferences and operational details.&lt;/p&gt;
&lt;p&gt;LLMs used to be lackadaisical about following rules. No longer. If you tell them exactly what to do, they will do exactly that. That can be helpful! But in the real, messy world, it&#39;s extraordinarily difficult to define in advance a good set of rules. Instead, we constantly exercise judgment. Agents are really good at on-the-fly judgment now. Delegation beats micromanagement.&lt;/p&gt;
&lt;p&gt;Most system prompts should be deleted. Most skills should be deleted. Most AGENTS.md should be deleted. It&#39;s all getting in the way now; the &lt;a href=&#34;http://www.incompleteideas.net/IncIdeas/BitterLesson.html&#34;&gt;bitter lesson&lt;/a&gt; has come for harnesses.&lt;/p&gt;
&lt;p&gt;My personal CLAUDE.md is 3 lines long. Here it is:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Do not git push, ever, under any circumstances.&lt;/li&gt;
&lt;li&gt;Do not hand-edit Go imports. Run &lt;code&gt;goimports -w&lt;/code&gt; after every edit.&lt;/li&gt;
&lt;li&gt;When writing prompts for other agents, convey intent, nuance, and operational details rather than prescriptive instructions—goals are durable, orders are brittle. Trust and delegate over command and control.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I look forward to deleting the goimports line in the near future.&lt;/p&gt;
&lt;p&gt;I&#39;d also love to nix the last line, which unfortunately doesn&#39;t even work completely. Claude doesn&#39;t understand yet that we don&#39;t live in 2025.&lt;/p&gt;
&lt;p&gt;When Claude barks orders like a drill sergeant, it erases the underlying purpose. Every layer of subagents loses ever more fidelity, like a game of LLM telephone.&lt;/p&gt;
&lt;p&gt;The thing is: agents prompt agents all the time. Agents help people write skills. Agents invoke subagents. Agents write scripts that run agents.&lt;/p&gt;
&lt;p&gt;Shelley, the exe.dev coding agent, has an orchestrator mode. It works around this form of context collapse by giving all subagents access to a SQLite database containing the entire set of all conversations. Subagents refer back to the user&#39;s input as a primary source.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Everyone Is Building a Software Factory</title>
    <link href="https://blog.exe.dev/bones-of-the-software-factory" />
    <id>https://blog.exe.dev/bones-of-the-software-factory</id>
    <updated>2026-03-27T00:00:00Z</updated>
    <summary>Is exe.dev the compute primitive you&#39;ve been waiting for?</summary>
    <content type="html">&lt;p&gt;We are all grappling with what it means to be an organization with agentic tools. We are seeing a Cambrian explosion of workflows in how to produce software. It is unwise, right now, to declare The Solution and enforce it. Developer Productivity teams that are pushing a workflow on their users are being counterproductive. Instead, the moment calls for experimentation and for giving people the agency to experiment, to learn, to iterate.&lt;/p&gt;
&lt;p&gt;The key is the &lt;strong&gt;compute primitive&lt;/strong&gt;. You–and everyone else on your team–need to have plentiful, performant, trivial-to-provision VMs that can be accessed from your phone or anywhere, that can be shared securely, that integrate nicely, and that can be trusted with your data. Given this, you&#39;ll find an explosion of agents, automations, UIs, workflows, notifications, bots, claws, and so on. The successful ones will evolve to be the bones of your software factory.&lt;/p&gt;
&lt;p&gt;This is not a &lt;em&gt;One Size Fits All&lt;/em&gt; moment. This is an &lt;em&gt;Everyone&#39;s Workflow is Different&lt;/em&gt; moment.&lt;/p&gt;
&lt;p&gt;We went around the office recently, and talked through our workflows. 7 people. 9 workflows. (Not a joke!) Everyone&#39;s are different. Everyone&#39;s are wonderful. There&#39;s the newsletter that visits our Slack and tells us what&#39;s going on in support rotation. There&#39;s the integration with our Clickhouse logs. There&#39;s the background agent fighting the noble fight against test flakes. There are multi-agent orchestrators. There&#39;s an &amp;quot;inbox&amp;quot; view that gathers agent conversation state from all the VMs and sorts them by recency and annotates whether they&#39;ve been pushed. There&#39;s vanilla Claude Code. There&#39;s &lt;a href=&#34;https://pi.dev/&#34;&gt;the pi coding agent&lt;/a&gt;. There&#39;s our own coding agent, &lt;a href=&#34;https://exe.dev/shelley&#34;&gt;Shelley&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;The only common denominator? We&#39;re all using VMs to isolate, try, share, iterate, parallelize. So many VMs.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>February Update</title>
    <link href="https://blog.exe.dev/feb26-update" />
    <id>https://blog.exe.dev/feb26-update</id>
    <updated>2026-03-09T00:00:00Z</updated>
    <summary>Roundup of exe.dev work in February.</summary>
    <content type="html">&lt;p&gt;February kept us busy! Thanks to all our users for the great feedback, so many bug fixes and quick improvements were possible because of high quality reports.&lt;/p&gt;
&lt;p&gt;Here are a few things we shipped in February:&lt;/p&gt;
&lt;h2&gt;Idea templates&lt;/h2&gt;
&lt;p&gt;The &lt;a href=&#34;https://exe.dev/new&#34;&gt;new VM page&lt;/a&gt; now has a gallery of &lt;strong&gt;idea templates&lt;/strong&gt;: one-click setups for apps like Gitea, VS Code, Ghost, Minecraft, Grafana, Outline, and more. Each template comes with a tailored prompt that Shelley uses to set up the app automatically, including auth configuration. And of course it includes the most popular one, OpenClaw.&lt;/p&gt;
&lt;p&gt;More than anything, the goal of idea templates is to demonstrate what you can do with a prompt. That empty text box is far more powerful than it looks.&lt;/p&gt;
&lt;p&gt;Take a look at them at &lt;a href=&#34;https://exe.dev/idea&#34;&gt;exe.dev/idea&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;HTTPS API&lt;/h2&gt;
&lt;p&gt;We published an HTTPS &lt;a href=&#34;https://exe.dev/docs/https-api&#34;&gt;API&lt;/a&gt;. You can now script exe.dev programmatically — create VMs, manage them, and integrate with your existing tooling — from systems that cannot SSH. There is a particularly fun approach to API tokens using SSH key signing.&lt;/p&gt;
&lt;h2&gt;Shelley&lt;/h2&gt;
&lt;p&gt;Shelley has had a busy month. With &lt;strong&gt;conversation distillation&lt;/strong&gt;, Shelley uses an LLM to restart the context window with just the right context to continue the conversation. The &lt;strong&gt;browser tool&lt;/strong&gt; learned new tricks, including taking profiles of its browsing for web development, which in turn yielded some performance improvements in the UI. By popular demand, &lt;strong&gt;Markdown rendering&lt;/strong&gt; now happens in conversations by default. You can run &lt;code&gt;!bash&lt;/code&gt; in the chat window and &lt;strong&gt;pop a shell&lt;/strong&gt;. We always keep up with the &lt;strong&gt;newest models&lt;/strong&gt;. Enable &lt;strong&gt;notifications&lt;/strong&gt; in the ⌘K palette so you can stay on top of your agents. Use Shelley across a wide variety of (human) langauges with &lt;strong&gt;internationalization support&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;exe.dev also now supports buying LLM credits as you go.&lt;/p&gt;
&lt;p&gt;As always, you can find us in &lt;a href=&#34;https://discord.gg/jc9WQUfaxf&#34;&gt;our discord&lt;/a&gt;.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>APIs for the RESTless</title>
    <link href="https://blog.exe.dev/apis-for-the-restless" />
    <id>https://blog.exe.dev/apis-for-the-restless</id>
    <updated>2026-03-05T00:00:00Z</updated>
    <summary>Mint your own bearer tokens for exe.dev&#39;s HTTP API.</summary>
    <content type="html">&lt;p&gt;Exe.dev&#39;s API to create a new machine is:&lt;/p&gt;
&lt;pre&gt;ssh exe.dev &lt;b&gt;new --name=restless --json&lt;/b&gt;&lt;/pre&gt;
&lt;p&gt;That assumes your SSH key is already registered to your account.&lt;/p&gt;
&lt;p&gt;If you want to do it over HTTPS, it&#39;s:&lt;/p&gt;
&lt;pre&gt;curl -X POST https://exe.dev/exec \
  -H &#34;Authorization: Bearer $TOKEN&#34; \
  -d &#39;&lt;b&gt;new --name=restless --json&lt;/b&gt;&#39;&lt;/pre&gt;
&lt;p&gt;Our CLI and our API are one and the same. The conventions are unix-y (how to
parse command-line flags) rather than web-by, but they&#39;re familiar to our end
users, and you don&#39;t have to learn two different conventions.&lt;/p&gt;
&lt;h2&gt;Minting Your Own Tokens&lt;/h2&gt;
&lt;p&gt;The only tricky bit is giving our users bearer tokens, and here we did
something new: you can use your SSH key to mint your own tokens, and you can
give those self-minted tokens restrictions (when they&#39;re valid, what they can
do) without chatting with us. If the signature checks out, we know that the
token was generated by the SSH private key.&lt;/p&gt;
&lt;p&gt;We walk through building a token step by step in
&lt;a href=&#34;https://exe.dev/docs/https-api&#34;&gt;our documentation&lt;/a&gt;, but this shell function
does the trick:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code class=&#34;language-bash&#34;&gt;exetoken() {
  # Generate an exe.dev API token.
  #   exetoken [permissions_json] [ssh_key_path]
  #   permissions_json defaults to &amp;#39;{}&amp;#39; (no restrictions)
  #   ssh_key_path defaults to the first IdentityFile from ssh config
  local perms
  if [ -n &amp;#34;$1&amp;#34; ]; then
    perms=&amp;#34;$1&amp;#34;
  else
    perms=&amp;#39;{}&amp;#39;
  fi
  local key
  if [ -n &amp;#34;$2&amp;#34; ]; then
    key=&amp;#34;$2&amp;#34;
  else
    local default_key=$(ssh -G exe.dev | grep -i identityfile | head -n1 | awk &amp;#39;{print $2}&amp;#39;)
    key=&amp;#34;${default_key/#\~/$HOME}&amp;#34;
  fi
  b() { tr -d &amp;#39;\n=&amp;#39; | tr &amp;#39;&#43;/&amp;#39; &amp;#39;-_&amp;#39;; }
  local p=$(printf &amp;#39;%s&amp;#39; &amp;#34;$perms&amp;#34; | base64 | b)
  local s=$(printf &amp;#39;%s&amp;#39; &amp;#34;$perms&amp;#34; | ssh-keygen -Y sign -f &amp;#34;$key&amp;#34; -n v0@exe.dev 2&amp;gt;/dev/null | sed &amp;#39;1d;$d&amp;#39; | b)
  echo &amp;#34;exe0.$p.$s&amp;#34;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The key aspects here are the inputs:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A &lt;strong&gt;permissions&lt;/strong&gt; JSON — e.g. &lt;code&gt;{&amp;quot;cmds&amp;quot;:[&amp;quot;whoami&amp;quot;]}&lt;/code&gt; says &amp;quot;this key can
execute the &lt;code&gt;whoami&lt;/code&gt; command.&amp;quot;&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;SSH key&lt;/strong&gt; is the secret that signs the token.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The output is the permissions and the signature of the permissions,
encoded with URL-safe base64 to prevent any troubles.&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code class=&#34;language-bash&#34;&gt;$ curl -s -X POST https://exe.dev/exec \
    -H &amp;#34;Authorization: Bearer $(exetoken &amp;#39;{&amp;#34;cmds&amp;#34;:[&amp;#34;whoami&amp;#34;]}&amp;#39;)&amp;#34; \
    -d whoami | jq -r &amp;#39;.email&amp;#39;
philip.zeyliger@bloggy.exe.xyz
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Gadzooks, it works!&lt;/p&gt;
&lt;h2&gt;Scopes, Expiry, and Revocation&lt;/h2&gt;
&lt;p&gt;You can associate multiple SSH keys with an exe.dev account. Removing an SSH
key from your exe.dev account revokes all tokens signed with that SSH key.&lt;/p&gt;
&lt;p&gt;This, dare we say unusual, scheme gives you scopes, expiry, offline token
creation, and revocation. We admit it&#39;s a little weird.&lt;/p&gt;
&lt;h2&gt;Extending to the SSH Auth Proxy&lt;/h2&gt;
&lt;p&gt;Exe.dev VMs come with a built-in
&lt;a href=&#34;https://exe.dev/docs/proxy&#34;&gt;auth proxy&lt;/a&gt;. If you wanted to script talking to a
web server on your VM, you could log in manually and steal the cookie. Stealing
cookies is naughty, so you could instead mark the VM publicly accessible and
implement your own authentication. Our API keys give you a third way: mint a
bearer token scoped to just that VM, and access it directly.&lt;/p&gt;
&lt;p&gt;For VM tokens, the signing namespace changes from &lt;code&gt;v0@exe.dev&lt;/code&gt; to
&lt;code&gt;v0@myvm.exe.xyz&lt;/code&gt;:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code class=&#34;language-bash&#34;&gt;# Without a token — the proxy redirects you to log in:
$ curl -s -o /dev/null -w &amp;#34;%{http_code}&amp;#34; https://myvm.exe.xyz/api/data
307

# With a bearer token — you&amp;#39;re in:
$ curl -s -H &amp;#34;Authorization: Bearer $VM_TOKEN&amp;#34; https://myvm.exe.xyz/api/data
{&amp;#34;status&amp;#34;: &amp;#34;ok&amp;#34;}
&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;References&lt;/h2&gt;
&lt;p&gt;See &lt;a href=&#34;https://exe.dev/docs/https-api&#34;&gt;https://exe.dev/docs/https-api&lt;/a&gt; for the
full details, including how to mint short-lived tokens.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder and Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Why exe.dev VMs Are Persistent</title>
    <link href="https://blog.exe.dev/persistent" />
    <id>https://blog.exe.dev/persistent</id>
    <updated>2026-03-03T00:00:00Z</updated>
    <summary>On the design decision to make VMs persistent, with persistent disks.</summary>
    <content type="html">&lt;p&gt;When we were designing &lt;a href=&#34;https://exe.dev&#34;&gt;exe.dev&lt;/a&gt;, we settled on VMs being persistent, with persistent disks. VMs are &lt;em&gt;not&lt;/em&gt; “quiesced” when there’s no network traffic or SSH connections. Disks aren’t wiped clean on reboot.&lt;/p&gt;
&lt;p&gt;This flies in the face of modern “stateless,” “immutable,” or “serverless” infrastructure. Surely, we’re nuts. Why did we do this to our users and to ourselves?&lt;/p&gt;
&lt;p&gt;We want the environment to be familiar; more like a laptop than a remote container-what’s-it that you have to jump through hoops to even get a shell on. (Who amongst us hasn’t run &lt;code&gt;tmate&lt;/code&gt; as part of their CI workflow to pop a shell in the darn ephemeral machine to figure out what’s going on…)&lt;/p&gt;
&lt;p&gt;We don’t want to force you into a distributed system, which is what you have the moment you have a remote SQL database to store your data. (As a wise person once told me, “You have a problem. You add a distributed system. Now you have two problems.”) (And those problems can’t even reliably talk to each other.)&lt;/p&gt;
&lt;p&gt;We want cron jobs to just work. Systemd timers too.&lt;/p&gt;
&lt;p&gt;Should you want to use a coding agent, we want it to be able to both write AND operate whatever you’re building. (See also &lt;a href=&#34;/software-as-wiki&#34;&gt;Software as a Wiki&lt;/a&gt;.)&lt;/p&gt;
&lt;p&gt;We want to spare you the need to fuss with container registries. We want to make the easy things obvious.&lt;/p&gt;
&lt;p&gt;We don’t want to force you into a heavy-handed tool ecosystem. Heck, we don’t even want to force you into git when all you want is an internal tool or a prototype.&lt;/p&gt;
&lt;p&gt;We don’t want you to have to plug in API keys for another service, and then another, and then another to do basic things like receive e-mail or host a web page or store a file or write to a database.&lt;/p&gt;
&lt;p&gt;Every time we talked about quiescing, we realized it would break cron jobs. Every time we talked about GitHub integration, we groaned about git and GitHub’s complexity.&lt;/p&gt;
&lt;p&gt;So, we settled on VMs that keep running, and we’re doing the interesting work of scaling our infrastructure to keep those VMs running happily and effectively. We want our VMs big enough so that you can work on the big projects you already work on. (Please reach out if they’re not big enough!)&lt;/p&gt;
&lt;p&gt;And it’s working. As they say in the industry, we’re drinking our own champagne. We develop exe using exe VMs with the Shelley coding agent. We serve this blog on, you guessed it, an exe VM. Our silly link shortener uses exe VMs. Our log search/analysis database and agent: also an &lt;a href=&#34;https://exe.dev&#34;&gt;exe.dev&lt;/a&gt;VM.&lt;/p&gt;
&lt;p&gt;Go get yourself an exe.dev VM. Get a few. Get twenty.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Show, Don’t Tell</title>
    <link href="https://blog.exe.dev/show-dont-tell" />
    <id>https://blog.exe.dev/show-dont-tell</id>
    <updated>2026-02-22T00:00:00Z</updated>
    <summary>On the perils of marketing, and writing private apps from your phone.</summary>
    <content type="html">&lt;p&gt;I have been tasked, by process of elimination, with developing exe.dev’s marketing strategy.&lt;/p&gt;
&lt;p&gt;In one very important sense, marketing exe.dev is easy. I am proud of what we have built, so I am happy to talk about it to anyone who will do me the kindness of listening. Being happy enough with my work to talk about it is rare for me, and usually the biggest hurdle.&lt;/p&gt;
&lt;p&gt;In another sense, it is the worst time to talk about anything. The over-the-top marketing around AI is tiring. Yes, the technical possibilities created by LLMs are wondrous. I have not been this excited about computers since I got a modem! Yet the noise is deafening.&lt;/p&gt;
&lt;p&gt;With general SNR so low, the only marketing strategy that makes sense to me is: Show, don’t tell.&lt;/p&gt;
&lt;p&gt;It turns out we are already doing this, to an extent. We built a landing page back in December that was described by the top comment on HN as “the worst website ever” because all it does is tell you to &lt;code&gt;ssh exe.dev&lt;/code&gt;. Even there, what we show you is the infrastructure we built, that your agent needs. You need VMs. Lots of VMs. You need TLS and auth taken care of for you. You need it easy enough to use an agent can figure it out and have context window left over to write your program.&lt;/p&gt;
&lt;p&gt;This strategy is going really well! A lot of users have shown up, asking technical questions and we are growing rapidly.&lt;/p&gt;
&lt;p&gt;But along the way, it is easy for a lot of the value of the product to be hard to discover. I would like to tell you about one, but in the spirit of “show, don’t tell” let me show you something I have done with it.&lt;/p&gt;
&lt;h1&gt;Write private apps from your phone. Share them.&lt;/h1&gt;
&lt;p&gt;So I am going to walk through an example of the most powerful feature that is hard (today) to discover from our home page:&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://exe.dev/new&#34;&gt;exe.dev/new&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;Shelley is for your phone&lt;/h2&gt;
&lt;p&gt;In our default VM image, we install codex and claude. We also include our own agent, Shelley. It is the second general-purpose programming agent we have written, and we wrote it for a very particular reason: we need an agent with a web UI.&lt;/p&gt;
&lt;p&gt;The need for a web UI is debatable on a desktop. There are clear advantages, but also drawbacks. But on mobile the case is clear. I’m not going to press a teeny tiny “Ctrl&#43;Z” button in an iOS terminal emulator. Sorry. I need all the affordances of mobile UI design from the past 19 years to be able to use such a tiny screen without a real keyboard.&lt;/p&gt;
&lt;p&gt;With this, you can visit exe.dev/new and type in a prompt. We start a VM, and feed the prompt to the copy of Shelley running on your VM. Because it’s a fresh, isolated VM we have no permission nagging, the agent is root and can do whatever it needs to get the job done. (This is wonderfully powerful, so much so you should be sure to only do it in an isolated VM.)&lt;/p&gt;
&lt;p&gt;When you are done, in the exe.dev web UI you will find a share URL under your VM:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;https://anycaster.exe.xyz?share=AVERYSECRETTOKEN
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Send that to anyone and they can login by verifying their email (no subscription required). Your app is private by default but shared easily.&lt;/p&gt;
&lt;h2&gt;Example: anycaster&lt;/h2&gt;
&lt;p&gt;This is the “show, don’t tell” part of the post. Here is a real app I wrote, on my phone, to do serious work.&lt;/p&gt;
&lt;p&gt;As part of rolling out exe.dev to multiple regions, we are exploring putting all of our VMs automatically behind a global anycast network. The sort of thing you might buy, e.g. AWS GLB, but we are doing it with more direct vendors because, well, we intend to be a cloud provider. That means doing the work.&lt;/p&gt;
&lt;p&gt;So we rolled out a small set of global frontends and had a /24 anycast onto it by one of the vendors. It seemed to work. But I noticed surprisingly long ping times from home. So I added an endpoint to our frontends reporting location, much like you can do with Cloudflare:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;curl -s https://1.1.1.1/cdn-cgi/trace | grep colo
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;What I found was my home network (in California) was misrouting to our Frankfurt frontend. Ouch.&lt;/p&gt;
&lt;p&gt;So I wanted to report this to the netops team we are working with so they could fix it, but I also wanted to build out our own tooling for testing routes we care about. (These tools exist, but I wanted to log history and use them from my phone.) So I went to exe.dev/new, and typed in:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;Hello. The anycaster server is designed to test exe.dev anycast.
Setup Tailscale with the token:  TS_TOKEN=... 

Write a Go server that, every hour, uses
`tailscale exit-node list --filter=` to find a Mullvad exit node in
the right region, uses `tailscale set --exit-node=` to set the
machine to use it, and then inspects the state of the world with:

    curl -s https://1.1.1.1/cdn-cgi/trace | grep colo

This is our base standard about &amp;#34;where we are&amp;#34;.
Then run:

    curl -s http://&amp;lt;our anycast IP&amp;gt;/debug/who

This is the test of our anycast, and tells you which of our servers
we are connected to. You can get the list of frontends with: …

I want you to test access from (and if these exact locations don&amp;#39;t
exist, something geographically near): …

Then for each of these run:
    sudo mtr -rwzbs 200 --tcp -P 80 &amp;lt;our anycast IP&amp;gt;
to give us a route to the target.

Store the results in an sqlite DB.
Each of these should connect to the geographically closest FE.
Show the latest results on the web page of anycaster.
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;This is a long prompt to type out on a phone, but I was walking to a meeting and I generally type far too much on my phone. The TS_TOKEN I keep in an Apple Note for apps like these. (I realize that’s not great! I am working on trying to get Tailscale setup to be easier on exe.dev. You could also for this case skip Tailscale and use the mullvad client directly. But I write apps with what I know.)&lt;/p&gt;
&lt;p&gt;I put my phone away, had the meeting, and then afterwards pulled it out and found this app waiting for me:&lt;/p&gt;
&lt;img src=&#34;/assets/anycaster.png&#34; style=&#34;width: 400px;&#34; alt=&#34;A screenshot of anycaster, showing testing network routes from different locations&#34;&gt;
&lt;p&gt;This is a recent screenshot. The original version had fewer frontends, and more ✗ results. Our anycast network needed a lot of tuning.&lt;/p&gt;
&lt;p&gt;I sent the share link to the netops team and asked them to fix it. They did! Minus whatever strange thing is happening in Chicago, I still need to investigate if that’s weirdness from Mullvad or from our anycast routing.&lt;/p&gt;
&lt;p&gt;Over the next couple of weeks I tweaked it. In my Shelley conversation history you’ll find prompts like:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;Two things please:
- add an &amp;#34;edit in Shelley&amp;#34; button to anycaster to bring me here
- relax Miami so it can connect to DAL
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;And:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;We now have enough things to test that it&amp;#39;s slow. I believe all
the time is in running mtr. So let&amp;#39;s do it in two phases:
1. go through them all and collect status.
2. when complete, go through the ones that fail and collect MTR.
Make it clear what&amp;#39;s happening visually.
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;One big thing I changed was, every hour when this server ran the test, switching the exit node cut off my access to the web server. We have a plan to fix this generally for exe.dev users by improving some of our in-VM isolation, but until we did I wanted a quick fix. Out of curiosity, I typed in this prompt:&lt;/p&gt;
&lt;p&gt;The current anycaster works well. However, when it is running the tests, the reconfiguration of Tailscale appears to break the exe.dev sshd server and thus the website (which proxies through it).&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;Is it possible to use Tailscale in an isolated network namespace?
We can then run our connection tests like the mtr tool in that namespace.
Please try implementing it.
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;This was me, honestly, being silly. There is no world in which I would waste hours digging through the poor documentation around the &lt;code&gt;netns&lt;/code&gt; command for a little dashboard app like this, all over a minor inconvenience. I could lose a couple of days to something ridiculous like this in the pre-LLM world. But when you’re typing idly on a phone you can dream of software you would never realistically write.&lt;/p&gt;
&lt;p&gt;When I came back Shelley left me with a summary and some ASCII art:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;### Changes Made

1. **`tailscale-netns.service`** - New systemd service that:
   - Creates a Linux network namespace called `tailscale`
   - Sets up a veth pair (`veth-host` ↔ `veth-ts`) to connect namespace to host
   - Configures IPs (10.200.200.1/24 on host, 10.200.200.2/24 in namespace)
   - Enables IP forwarding and NAT so namespace can reach the internet
   - Cleans up on stop

...

### How It Works

┌─────────────────────────────────────────────────────────┐
│ HOST (exe.dev VM)                                       │
│                                                         │
│  eth0 ─────────────────────────────────► Internet       │
│  (exe.dev sshd uses this directly)                      │
│                                                         │
│  veth-host (10.200.200.1)                               │
│      │                                                  │
│      │ NAT                                              │
│      ▼                                                  │
│  ┌───────────────────────────────────────────┐          │
│  │ NAMESPACE &amp;#34;tailscale&amp;#34;                     │          │
│  │                                           │          │
│  │  veth-ts (10.200.200.2)                   │          │
│  │      │                                    │          │
│  │      ▼                                    │          │
│  │  tailscale0 ────► Exit nodes ────► Tests  │          │
│  │                                           │          │
│  └───────────────────────────────────────────┘          │
└─────────────────────────────────────────────────────────┘

- **Host traffic** (including exe.dev sshd) uses eth0 directly
- **Anycaster tests** run `curl`/`mtr` inside the namespace
- **tailscale CLI** commands work from outside
  (socket-based communication)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;It worked.&lt;/p&gt;
&lt;p&gt;It dug its way through all these painfully undocumented Linux subsystems and isolated my Tailscale daemon in a network namespace. Every hour when the namespace starts changing its location, I can still access the web server. In fact I wrote a few more prompts to add nice status updates about the background work to the UI.&lt;/p&gt;
&lt;p&gt;The result of all of this is we are still investigating and trialing vendor products for our global network frontend, and studying how these products handle changing network routes. We hope to launch something soon.&lt;/p&gt;
&lt;h1&gt;A note on the future of engineering&lt;/h1&gt;
&lt;p&gt;What is surprising to me, in retrospect, is at no point in writing or using this app, or sharing it with half a dozen netops folks, did I ever look at the code. I spot checked the outputs, I looked at the bad mtr traces and made sure the conclusions fit with the data. We eventually cross-checked with RIPE. The output is correct. I am writing serious business tools that affect the company’s decisions, with prompts, from my phone.&lt;/p&gt;
&lt;p&gt;Again, I don’t want to oversell anything. I have used Shelley to prototype changes to our web UI and add minor features. But almost all of our changes to exe.dev infrastructure are done on desktop. We read source changes to critical systems very carefully.&lt;/p&gt;
&lt;p&gt;What we see here is a new kind of small private shareable app development appearing. You won’t be writing a web browser in it any time soon. But you might be building fun programs for friends or colleagues that you couldn’t fit in a spreadsheet.&lt;/p&gt;
&lt;p&gt;Write some fun games with your kids on the couch. Or clone a round of &lt;em&gt;Only Connect&lt;/em&gt;. Before you know it you will think of something you need at work and want to share with the team.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Review the Reviews</title>
    <link href="https://blog.exe.dev/review-the-reviews" />
    <id>https://blog.exe.dev/review-the-reviews</id>
    <updated>2026-02-15T00:00:00Z</updated>
    <summary>The code reviewer reviewer reviews the code reviewer&#39;s reviews.</summary>
    <content type="html">&lt;p&gt;When I was actively contributing to the Go project, my primary feed was the &lt;a href=&#34;https://go-review.googlesource.com/&#34;&gt;code review&lt;/a&gt; email firehose.&lt;/p&gt;
&lt;p&gt;Issues, mailing lists, and Slack had low SNR. The finished commit history was better: it was finely polished work with some of the best written commit messages I have ever encountered. But it didn&#39;t hold a candle to code reviews for operational learning.&lt;/p&gt;
&lt;p&gt;The commit history could tell you what got done and why, in impressive technical detail. But the code review could also tell you about mid-stream direction changes; what concerns were taken seriously; what got started and not completed; what values drove decisions.&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;I&#39;m reflecting on that this morning because of &lt;a href=&#34;https://simonwillison.net/2026/Feb/15/cognitive-debt/&#34;&gt;Simon Willison&#39;s comments about cognitive debt&lt;/a&gt;:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;I&#39;ve been experimenting with prompting entire new features into existence without reviewing their implementations and, while it works surprisingly well, I&#39;ve found myself getting lost in my own projects.&lt;/p&gt;
&lt;p&gt;I no longer have a firm mental model of what they can do and how they work, which means each additional feature becomes harder to reason about, eventually leading me to lose the ability to make confident decisions about where to go next.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Having a human in the loop benefits the human. But where?&lt;/p&gt;
&lt;p&gt;Reading code reviews was effective for the Go project. It still is.&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;My workflow has churned over the last year. But here&#39;s what I do now: I review reviews.&lt;/p&gt;
&lt;p&gt;I ask an agent to do something. Code happens. I then ask an agent to review that code, without looking at it myself. Then I review the review.&lt;/p&gt;
&lt;p&gt;The agent&#39;s review typically contains design commentary, questions about decisions made, bugs, and nits. This is usually enough for me to get a clear idea about what&#39;s going on in the code, at the right level of abstraction. And it enables me to very efficiently provide direction.&lt;/p&gt;
&lt;p&gt;I have a heavily used code review skill that optimizes for this workflow:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Number all comments, questions, and suggestions for easy reference. Use an ever-incrementing scheme starting at 1.&lt;/p&gt;
&lt;p&gt;Format:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Top-level items: &lt;code&gt;1.&lt;/code&gt;, &lt;code&gt;2.&lt;/code&gt;, &lt;code&gt;3.&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Sub-items: &lt;code&gt;2a.&lt;/code&gt;, &lt;code&gt;2b.&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;This lets the user respond concisely and unambiguously: &amp;quot;3: please fix&amp;quot; or &amp;quot;2b: stet&amp;quot;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;An agent who has just done a code review has an ideally primed context window for working on that code. It makes fixes for me.&lt;/p&gt;
&lt;p&gt;And as you might have guessed, when those fixes are done, I amend the commit unseen and start another code review cycle. When the code reviews stabilize, I skim the final commit. There are rarely any surprises.&lt;/p&gt;
&lt;p&gt;The reviews rarely actually come back clean. Rather, they converge on commentary I&#39;ve already decided to ignore, places where the model weights and I flatly disagree.&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;The numbers bear this out. I just asked Claude to look over the entire history of the initial prompts I give it and do some light analysis.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Top 1-grams: &lt;a href=&#34;https://commaok.xyz/ai/manners/&#34;&gt;&lt;code&gt;please&lt;/code&gt;&lt;/a&gt; (2.03%), &lt;code&gt;codereview&lt;/code&gt; (0.64%), &lt;code&gt;look&lt;/code&gt; (0.61%), &lt;code&gt;use&lt;/code&gt; (0.58%), &lt;code&gt;make&lt;/code&gt; (0.51%)&lt;/p&gt;
&lt;p&gt;Top 2-grams: &lt;code&gt;look at&lt;/code&gt; (0.41%), &lt;code&gt;please codereview&lt;/code&gt; (0.39%), &lt;code&gt;i want&lt;/code&gt; (0.34%), &lt;code&gt;want to&lt;/code&gt; (0.29%), &lt;code&gt;add a&lt;/code&gt; (0.21%)&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;I learned while writing this blog post that &amp;quot;code review&amp;quot; is two words. RIP stats.&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;My life is now officially Seussian. I watch the watchers.&lt;/p&gt;
&lt;img src=&#34;/assets/beewatcher.jpg&#34; alt=&#34;The Bee Watcher&#34; style=&#34;max-width: 100%; height: auto; border-radius: 8px;&#34;&gt;
&lt;p&gt;&lt;em&gt;Cross-posted at &lt;a href=&#34;https://commaok.xyz/ai/review-the-reviews/&#34;&gt;commaok.xyz/ai/review-the-reviews/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Software as Wiki, Mutable Software</title>
    <link href="https://blog.exe.dev/software-as-wiki" />
    <id>https://blog.exe.dev/software-as-wiki</id>
    <updated>2026-02-13T00:00:00Z</updated>
    <summary>When your coding agent lives next to your software, editing it is as easy as editing a wiki.</summary>
    <content type="html">&lt;style&gt;
.wiki-hero {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 12px;
  margin: 2em 0;
}
.wiki-hero-panel {
  text-align: center;
  flex: 1;
  min-width: 200px;
}
.wiki-hero-panel img.screenshot {
  max-width: 100%;
  border-radius: 8px;
}
.wiki-hero-arrow {
  font-size: 32px;
  flex-shrink: 0;
}
.wiki-hero-inset {
  width: 180px;
  height: 70px;
  margin: 8px auto 0;
  border-radius: 6px;
  overflow: hidden;
  position: relative;
}
.wiki-hero-inset img {
  display: block;
  width: 600px;
  max-width: none;
  position: absolute;
}
.wiki-hero-inset-slinky {
  border: 2px solid #e8a735;
}
.wiki-hero-inset-slinky img {
  left: -453px;
  top: -70px;
}
.wiki-hero-inset-shelley {
  border: 2px solid #4a7dff;
}
.wiki-hero-inset-shelley img {
  left: -420px;
  top: -184px;
}
.wiki-hero-caption {
  font-size: 12px;
  color: rgba(0,0,0,0.5);
  margin-top: 4px;
}
@media (max-width: 600px) {
  .wiki-hero {
    flex-direction: column;
    gap: 24px;
  }
  .wiki-hero-panel {
    min-width: 0;
    width: 100%;
  }
  .wiki-hero-arrow {
    transform: rotate(90deg);
  }
  .wiki-hero-inset {
    width: 240px;
    height: 94px;
  }
  .wiki-hero-inset img {
    width: 800px;
  }
  .wiki-hero-inset-slinky img {
    left: -604px;
    top: -93px;
  }
  .wiki-hero-inset-shelley img {
    left: -560px;
    top: -245px;
  }
}
&lt;/style&gt;
&lt;div class=&#34;wiki-hero&#34;&gt;
  &lt;div class=&#34;wiki-hero-panel&#34;&gt;
    &lt;img class=&#34;screenshot&#34; src=&#34;https://boldsoftware.github.io/public_html/slinky/slinky.png&#34; alt=&#34;Slinky link shortener&#34; /&gt;
    &lt;div class=&#34;wiki-hero-inset wiki-hero-inset-slinky&#34;&gt;
      &lt;img src=&#34;https://boldsoftware.github.io/public_html/slinky/slinky.png&#34; alt=&#34;&#34; /&gt;
    &lt;/div&gt;
    &lt;div class=&#34;wiki-hero-caption&#34;&gt;&#34;Edit with Shelley&#34;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class=&#34;wiki-hero-arrow&#34;&gt;&amp;#8644;&lt;/div&gt;
  &lt;div class=&#34;wiki-hero-panel&#34;&gt;
    &lt;img class=&#34;screenshot&#34; src=&#34;https://boldsoftware.github.io/public_html/slinky/shelley.png&#34; alt=&#34;Shelley editing Slinky&#34; /&gt;
    &lt;div class=&#34;wiki-hero-inset wiki-hero-inset-shelley&#34;&gt;
      &lt;img src=&#34;https://boldsoftware.github.io/public_html/slinky/shelley.png&#34; alt=&#34;&#34; /&gt;
    &lt;/div&gt;
    &lt;div class=&#34;wiki-hero-caption&#34;&gt;&#34;slinky.exe.xyz&#34;&lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;Here at the exe.dev offices, we built a link shortener. It&#39;s called slinky. It&#39;s nothing special.&lt;/p&gt;
&lt;p&gt;Link shorteners are a dime a dozen. They help in a time of useless URLs (hi,
Google Docs), hard to remember port numbers, and overly clever naming schemes.&lt;/p&gt;
&lt;p&gt;The thing that makes this link shortener unusual, is that &amp;quot;Edit with Shelley&amp;quot;
button. When I wanted to add a feature (%s placeholders in short links for
Honeycomb queries for a trace id, say), I click on that, and I&#39;m in the Shelley
agent, on the same VM. I said, and I quote:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Some slinky URLs have &amp;quot;template&amp;quot; parameters. For example, I want
http://slinky.exe.xyz/trace/foo to become
https://ui.honeycomb.io/[%20 %20 so much quoting %20]foo[...]
Note how &amp;quot;foo&amp;quot; has to be replaced in that mess of escaping. Create a way to put
a placeholder in the link, and reference it like I mention. While you&#39;re add [sic]
it, add a link for this one.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;And then a few minutes later, Shelley had one-shotted this small feature to Slinky.&lt;/p&gt;
&lt;p&gt;You can treat some software like a wiki. You don&#39;t like it? Click &amp;quot;edit&amp;quot; and change it.&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>January Update</title>
    <link href="https://blog.exe.dev/jan26-update" />
    <id>https://blog.exe.dev/jan26-update</id>
    <updated>2026-02-08T00:00:00Z</updated>
    <summary>Roundup of exe.dev work in January.</summary>
    <content type="html">&lt;p&gt;It has been a busy month for exe.dev! We launched in late December and have been hard at work keeping the service online.&lt;/p&gt;
&lt;p&gt;Along the way we found some time to ship some features. Of note:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The &lt;strong&gt;new &lt;a href=&#34;https://exe.dev/docs/cli-cp&#34;&gt;&lt;code&gt;cp&lt;/code&gt; command&lt;/a&gt;&lt;/strong&gt; to make a fast copy of a VM to another VM. Under the hood this is implemented as copy-on-write, so no matter how complex your configuration gets, expect your new VM in a couple of seconds.&lt;/p&gt;
&lt;p&gt;This can be a useful way to set up a “base” VM, with the tools and configuration you expect in your development environment. When you need a fresh workspace:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;ssh exe.dev cp yourbase yourbranch&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A &lt;a href=&#34;https://exe.dev/docs/cli-restart&#34;&gt;&lt;code&gt;restart&lt;/code&gt; command&lt;/a&gt; in the SSH lobby. Sometimes VMs find themselves in untenable states. This is the first in a set of tools to help you manage the VM externally.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://exe.dev/docs/cli-rename&#34;&gt;Rename&lt;/a&gt; your VMs after you create them. Naming things is hard, sometimes you need a second take.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The web UI &lt;a href=&#34;https://exe.dev/user&#34;&gt;billing portal!&lt;/a&gt; Does this make VMs go faster? No. But can you now clearly see and manage the state of your exe.dev account? Yes.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Early work on larger disks. We intend to let you self-serve larger disks soon, but until then, support requests for a VM with a larger disk are often answered positively!&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://exe.dev/docs/send-email&#34;&gt;Send email&lt;/a&gt; from your VM! Currently you can only send emails to yourself, but even this is surprisingly useful for building small apps that need to notify you. All you need is curl.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://exe.dev/docs/receive-email&#34;&gt;Receive email&lt;/a&gt; on your VM! Any email sent to &lt;code&gt;*@vmname.exe.xyz&lt;/code&gt; can be delivered directly to your VM, all you need to do is enable it in the lobby:&lt;/p&gt;
&lt;p&gt;&lt;code&gt;ssh exe.dev share receive-email vmname on&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;DNS records are now &lt;a href=&#34;https://github.com/boldsoftware/exe.dev/issues/32&#34;&gt;reliably created&lt;/a&gt; before the &lt;a href=&#34;https://exe.dev/docs/cli-new&#34;&gt;&lt;code&gt;new&lt;/code&gt; command&lt;/a&gt; completes, so you can write scripts like:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;DOCKER_HOST=ssh://$(ssh exe.dev new --json | jq -r .ssh_dest)  
docker ps
&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Dark mode in the web UI, for people whose eyesight is too good.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Shelley&lt;/h2&gt;
&lt;p&gt;Shelley is the agent we run in the default image, and the one you use if you start a new VM with a prompt. It has seen significant development in January:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Shelley is now open-source. Give the &lt;a href=&#34;https://github.com/boldsoftware/shelley&#34;&gt;repo&lt;/a&gt; a star and read all about it on &lt;a href=&#34;https://blog.exe.dev/shelley&#34;&gt;our blog&lt;/a&gt;. Our default image, &lt;a href=&#34;https://github.com/boldsoftware/exeuntu&#34;&gt;exeuntu&lt;/a&gt;, is also open source.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Subagents, as well as a mechanism to continue a conversation in a new context once the context is exhausted.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Support for custom models, so you can bring your own model keys.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;We added support for skills.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The diff viewer in the conversation view is now &lt;a href=&#34;http://diffs.com&#34;&gt;diffs.com&lt;/a&gt;, and it’s pretty, if we say so ourselves.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Shelley can display an iframe with HTML output for your fancy visualizations. Ask Shelley to give you a “vega-lite visualization of the github activity in your repo” or something along those lines…&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;It’s pretty fun to type “!git show HEAD” or “!bash” in the chat.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Shelley can now upgrade itself from the UI.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The &lt;a href=&#34;https://en.wikipedia.org/wiki/Cool_S&#34;&gt;90s called&lt;/a&gt; and there’s a new favicon.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Much more is happening, expect to be seeing more posts like this! You can find us in &lt;a href=&#34;https://discord.gg/jc9WQUfaxf&#34;&gt;our discord&lt;/a&gt;.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Expensively Quadratic: the LLM Agent Cost Curve</title>
    <link href="https://blog.exe.dev/expensively-quadratic" />
    <id>https://blog.exe.dev/expensively-quadratic</id>
    <updated>2026-02-03T00:00:00Z</updated>
    <summary>Cache reads are quadratic and dominate your long agentic conversations.</summary>
    <content type="html">&lt;style&gt;
main { max-width: 900px; }
&lt;/style&gt;
&lt;p&gt;Pop quiz: at what point in the context length of a coding agent are cached reads costing you half of the next API call? By 50,000 tokens, your conversation’s costs are probably being dominated by cache reads.&lt;/p&gt;
&lt;p&gt;Let’s take a step back. We’ve &lt;a href=&#34;https://sketch.dev/blog/agent-loop&#34;&gt;previously written&lt;/a&gt; about how coding agents work: they post the conversation thus far to the LLM, and continue doing that in a loop as long as the LLM is requesting tool calls. When there are no more tools to run, the loop waits for user input, and the whole cycle starts over. Visually:&lt;/p&gt;
&lt;p&gt;&lt;object type=&#34;image/svg&#43;xml&#34; data=&#34;/assets/agentic-loop.svg&#34; style=&#34;max-width: 50%; height: auto;&#34;&gt;The agentic loop&lt;/object&gt;&lt;/p&gt;
&lt;p&gt;Or, in code form:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code class=&#34;language-python&#34;&gt;def loop(llm):
    msg = user_input()
    while True:
        output, tool_calls = llm(msg)
        print(&amp;#34;Agent: &amp;#34;, output)
        if tool_calls:
            msg = [handle_tool_call(tc)
                   for tc in tool_calls]
        else:
            msg = user_input()
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The LLM providers charge for input tokens, cache writes, output tokens, and cache reads. It&#39;s a little tricky: you indicate in your prompt to cache up to a certain point (usually the end), and you get charged as “cache write” and not input. The previous turn&#39;s output becomes the next turn&#39;s cache write. Visually:&lt;/p&gt;
&lt;p&gt;&lt;object type=&#34;image/svg&#43;xml&#34; data=&#34;/assets/quadratic-tokens.svg&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;Token costs across LLM calls&lt;/object&gt;&lt;/p&gt;
&lt;p&gt;Here, the colors and numbers indicate the costs making up the &lt;em&gt;n&lt;/em&gt;th call to the LLM. Every subsequent call reads the story so far from the cache, writes the previous call’s output to the cache (as well as any new input), and gets an output. The area represents the cost, though in this diagram, it&#39;s not quite drawn to scale. Add up all the rectangles, and that&#39;s the total cost.&lt;/p&gt;
&lt;p&gt;That triangle emerging for cache reads? That&#39;s the scary quadratic!&lt;/p&gt;
&lt;p&gt;How scary is the quadratic? Pretty squarey! I took a rather ho-hum feature implementation conversation, and visualized it like the diagram above. The area corresponds to cost: the width of every rectangle is the number of tokens and the height is the cost per token. As the conversation evolves, more and more of the cost is the long thin lines across the bottom that correspond to cache reads.&lt;/p&gt;
&lt;script src=&#34;https://cdn.jsdelivr.net/npm/vega@5&#34;&gt;&lt;/script&gt;
&lt;script src=&#34;https://cdn.jsdelivr.net/npm/vega-lite@5&#34;&gt;&lt;/script&gt;
&lt;script src=&#34;https://cdn.jsdelivr.net/npm/vega-embed@6&#34;&gt;&lt;/script&gt;
&lt;script src=&#34;/assets/quadratic.js&#34;&gt;&lt;/script&gt;
&lt;div id=&#34;token-viz&#34;&gt;&lt;/div&gt;
&lt;script&gt;renderTokenRectangles(&#39;/assets/quadratic.csv&#39;, &#39;#token-viz&#39;);&lt;/script&gt;
&lt;p&gt;The whole conversation cost $12.93 total or so. You can see that as the conversation continues, the cache reads dominate. At the end of the conversation, cache reads are 87% of the total cost. They were half the cost at 27,500 tokens!&lt;/p&gt;
&lt;div id=&#34;cost-viz&#34;&gt;&lt;/div&gt;
&lt;script&gt;renderCostChart(&#39;/assets/quadratic.csv&#39;, &#39;#cost-viz&#39;);&lt;/script&gt;
&lt;p&gt;This conversation is just one example. Does this happen generally? exe.dev&#39;s LLM gateway keeps track of the costs we&#39;re incurring. We do not store the messages themselves going past, but we do keep track of the number of tokens. The following graph shows the &amp;quot;cumulative cost&amp;quot; visualization for many Shelley conversations, not just my own. I sampled 250 conversations from the data randomly.&lt;/p&gt;
&lt;p&gt;The x-axis is the context length, and the y-axis is the cumulative cost up to that point. The left graph is all the costs and the right graph is just the cache reads. You can mouse over to find a given conversation on both graphs. The box plots below show the distribution of input tokens and output tokens.&lt;/p&gt;
&lt;div id=&#34;conversation-costs&#34;&gt;&lt;/div&gt;
&lt;script&gt;renderConversationCosts(&#39;/assets/opus_conversations.json&#39;, &#39;#conversation-costs&#39;);&lt;/script&gt;
&lt;p&gt;The cost curves are all different because every conversation is different. Some conversations write a lot of code, so spend more money on expensive output tokens. Some conversations read lots of the code base, so spend money on tool call outputs, which look like cache writes. Some conversations waited for the user while the cache expired, so have to re-write data to the cache. In our data, the median input was about 285 tokens and the median output was about 100, but the distribution is pretty wide.&lt;/p&gt;
&lt;p&gt;Let&#39;s look at how some conversations got to 100,000 tokens. We sampled from the same data set, but excluded short conversations under 20 calls and also excluded conversations that didn&#39;t get to 100,000 tokens. The number of LLM calls in the conversation matters quite a bit. The cache read cost isn&#39;t really the number of tokens squared; it&#39;s the number of tokens times the number of calls, and different conversations have very different numbers of LLM calls!&lt;/p&gt;
&lt;div id=&#34;cost-at-100k&#34;&gt;&lt;/div&gt;
&lt;script&gt;renderCostAt100k(&#39;/assets/cost_at_100k.json&#39;, &#39;#cost-at-100k&#39;);&lt;/script&gt;
&lt;p&gt;To go back to our original question, we can build a little simulator. Anthropic&#39;s rates are &lt;em&gt;x&lt;/em&gt; for input, 1.25&lt;em&gt;x&lt;/em&gt; for cache write, 5&lt;em&gt;x&lt;/em&gt; for output, and &lt;em&gt;x&lt;/em&gt;/10 for cache read, where &lt;em&gt;x&lt;/em&gt; = $5 per million tokens for Opus 4.5. In the default settings of the simulator, it only takes 20,000 tokens to get to the point where cache reads dominate.&lt;/p&gt;
&lt;div id=&#34;simulator&#34;&gt;&lt;/div&gt;
&lt;script&gt;renderCostSimulator(&#39;#simulator&#39;);&lt;/script&gt;
&lt;p&gt;As a coding agent developer and as an agent loop user, this cost structure gives me a lot to think about!&lt;/p&gt;
&lt;p&gt;One metaphor for this is &amp;quot;dead reckoning.&amp;quot; If we let the agent navigate a long task without feedback (in the form of tool calls and lots of back and forth), it will be cheaper, but, on the other hand, we know that it&#39;s the feedback that lets the agent find the right destination. All things being equal, fewer LLM calls is cheaper, but is the agent&#39;s internal compass off and is it going off in the wrong direction?&lt;/p&gt;
&lt;p&gt;Some coding agents (Shelley included!) refuse to return a large tool output back to the agent after some threshold. This is a mistake: it&#39;s going to read the whole file, and it may as well do it in one call rather than five.&lt;/p&gt;
&lt;p&gt;Subagents and tools that themselves call out to LLMs are a way of doing iteration outside of the main context window. Shelley uses a &amp;quot;keyword search&amp;quot; tool, for example, as an LLM-assisted grep.&lt;/p&gt;
&lt;p&gt;Starting conversations over might feel like it loses too much context, but the tokens spent on re-establishing context are very likely cheaper than the tokens spent on continuing the conversation, and often the effect will be the same. It always feels wasteful to start a new conversation, but then I remember that I start new conversations from my git repo all the time when I start on a new task; why is continuing an existing task any different?&lt;/p&gt;
&lt;p&gt;Are cost management, context management, and agent orchestrations all really the same problem? Is work like &lt;a href=&#34;https://alexzhang13.github.io/blog/2025/rlm/&#34;&gt;Recursive Language Models&lt;/a&gt; the right approach?&lt;/p&gt;
&lt;p&gt;These issues are very much on our minds as we work on &lt;a href=&#34;https://exe.dev&#34;&gt;exe.dev&lt;/a&gt; and &lt;a href=&#34;https://exe.dev/shelley&#34;&gt;Shelley&lt;/a&gt;. Let us know what you think!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Your Codebase Is the Prompt</title>
    <link href="https://blog.exe.dev/codebase-as-prompt" />
    <id>https://blog.exe.dev/codebase-as-prompt</id>
    <updated>2026-01-27T00:00:00Z</updated>
    <summary>When Claude writes code you don&#39;t like, ask what it saw, not what it did.</summary>
    <content type="html">&lt;p&gt;When Claude writes code I don&#39;t like, I used to mutter: &amp;quot;Oh Claude, what did you do?&amp;quot; I now ask instead: &amp;quot;Claude, what did you see?&amp;quot; And then I go address &lt;em&gt;that&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Here&#39;s a concrete example.&lt;/p&gt;
&lt;p&gt;At &lt;a href=&#34;https://exe.dev&#34;&gt;exe.dev&lt;/a&gt;, we have a very substantial end-to-end test suite. It is deeply empiricist: It only performs actions a user (including an admin) can perform, and it only observes state that a user (including an admin) can observe. This works very well with coding agents.&lt;/p&gt;
&lt;p&gt;Recently, Claude started writing end-to-end tests that reach into the database. At first, I told Claude not to do that, and it fixed it. Then I got smart. I asked Claude what tests it had modeled its new code on. Sure enough, they were also directly executing queries! Claude wasn&#39;t being sloppy; it was being consistent. I fixed the old tests and shut down the loophole in the test infrastructure.&lt;/p&gt;
&lt;p&gt;My typical prompt to a coding agent is a few sentences. Maybe a couple of paragraphs, if I&#39;m doing something really involved. The LLM then goes and reads thousands of lines or more from our codebase. Prompts come and go; your code endures.&lt;/p&gt;
&lt;p&gt;Agents mirror local style. Your codebase is the prompt. If you&#39;re using a state-of-the-art agent, and you don&#39;t like the code it generates, don&#39;t correct the agent. Instead, improve the code it learned from.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Cross-posted at &lt;a href=&#34;https://commaok.xyz/ai/codebase-as-prompt/&#34;&gt;commaok.xyz/ai/codebase-as-prompt/&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>SSH Has No Host Header</title>
    <link href="https://blog.exe.dev/ssh-host-header" />
    <id>https://blog.exe.dev/ssh-host-header</id>
    <updated>2026-01-22T00:00:00Z</updated>
    <summary>A dive into how we share IPs between VMs while making SSH work.</summary>
    <content type="html">&lt;p&gt;We have a challenge with ssh. Every VM has a standard URL that we use for both HTTPS and SSH, e.g. &lt;code&gt;undefined-behavior.exe.xyz&lt;/code&gt;. Just as you can type the domain into a web browser (and have TLS and auth taken care of for you), you can run:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;ssh undefined-behavior.exe.xyz
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;To get a shell in your VM.&lt;/p&gt;
&lt;p&gt;This is very straightforward to implement if you give each machine its own IP address, but exe.dev gives you many VMs on a flat rate subscription.&lt;/p&gt;
&lt;p&gt;We cannot issue an IPv4 address to each machine without blowing out the cost of the subscription. We cannot use IPv6-only as that means some of the internet cannot reach the VM over the web. That means we have to share IPv4 addresses between VMs.&lt;/p&gt;
&lt;p&gt;For the web, this is a long-solved problem. Many sites can and do have the same IP address. Web browsers send the domain they used to reach the server in the HTTP request as the &lt;code&gt;Host&lt;/code&gt; header. The exe.dev proxy switches on this header and send requests to the appropriate VM.&lt;/p&gt;
&lt;p&gt;SSH, on the other hand, has no equivalent of a Host header. If we reuse IPv4 addresses between VMs, we have no way to send SSH connections to the right VM.&lt;/p&gt;
&lt;h2&gt;How we solved this: SSH IP sharing&lt;/h2&gt;
&lt;p&gt;Instead of using one IP address for all VMs, we have a pool of public IPv4 addresses. Each VM is assigned a unique address relative to its owner.&lt;/p&gt;
&lt;p&gt;So instead of an A record, you will find&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;$ dig undefined-behavior.exe.xyz

; &amp;lt;&amp;lt;&amp;gt;&amp;gt; DiG 9.10.6 &amp;lt;&amp;lt;&amp;gt;&amp;gt; undefined-behavior.exe.xyz
...
;; ANSWER SECTION:
undefined-behavior.exe.xyz. 230 IN      CNAME   s003.exe.xyz.
s003.exe.xyz.           230     IN      A       16.145.102.7
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;&lt;em&gt;Relative to its owner&lt;/em&gt; means that while the IP represented by s003 is used by many VMs, it is only used by one VM owned by this user.&lt;/p&gt;
&lt;p&gt;This is all the extra information we need to route SSH connections. When SSH connects, it presents a public key and comes in via a particular IP address. The public key tells us the user, and the &lt;code&gt;{user, IP}&lt;/code&gt; tuple uniquely identifies the VM they are connecting to. In diagram form:&lt;/p&gt;
&lt;img src=&#34;/assets/ssh-proxy-tuple.svg&#34; alt=&#34;A diagram of ssh&#39;ing into an exe.dev VM&#34; style=&#34;max-width: 100%; height: auto;&#34;&gt;
&lt;p&gt;Building a proxy that does this requires some cross-system communication: when we create a VM we have to allocate it an IP carefully based on the user (or in the near future: team) that owns it. Our ssh proxy has to be able to determine the local IP a request came in on, which is easy on bare metal, harder in a cloud environment where public IPs are NATed on to private VPC addresses. All of this requires bespoke management software, so we cannot recommend it as a general solution to people who want to multiplex VM SSH access onto an IP. But uniform, predictable domain name behavior is important to us, so we took the time to build this for exe.dev.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Talk Emoji to Me</title>
    <link href="https://blog.exe.dev/talk-emoji" />
    <id>https://blog.exe.dev/talk-emoji</id>
    <updated>2026-01-15T00:00:00Z</updated>
    <summary>Emoji reactions are a surprisingly effective way to communicate with bots.</summary>
    <content type="html">&lt;p&gt;Start-ups sprout ad hoc processes constantly. I&#39;ve noticed an emerging theme among ours at &lt;a href=&#34;https://exe.dev/&#34;&gt;exe.dev&lt;/a&gt;: emoji reactions are a great way to communicate with bots.&lt;/p&gt;
&lt;p&gt;They’re efficient: adding an emoji is easy.&lt;/p&gt;
&lt;p&gt;They’re low noise: they don’t generate unread messages for anyone or threads to follow.&lt;/p&gt;
&lt;p&gt;They’re visible: other people can see that it has been done, and who did it.&lt;/p&gt;
&lt;p&gt;They&#39;re intuitive: 🪲 to auto-file an issue, 💡 for feature requests. And they take place in the exact context of whatever inspired action.&lt;/p&gt;
&lt;p&gt;Our bots also communicate back with emoji reactions. 👀 is a good placeholder for long-running requests. ✅ indicates success; 💥 is failure.&lt;/p&gt;
&lt;p&gt;Here’s a concrete example.&lt;/p&gt;
&lt;p&gt;We shipped invite codes today. How do we know when someone requests an invite code? It shows up in Slack. If we want to grant that person their code, we emoji respond with the number of invites to give them, e.g. 3️⃣. ✅ appears. Move on. Lightweight, easy, fast, and transparent.&lt;/p&gt;
&lt;p&gt;I can hear you saying, &amp;quot;Gee, this sounds like a great idea and all, but deploying a Slack bot is oodles of effort.&amp;quot; You will no doubt be shocked to learn that our Slack bot and Discord bot run on &lt;a href=&#34;https://exe.dev/&#34;&gt;exe.dev&lt;/a&gt;. When my colleague wanted to add another emoji handler, he pulled up &lt;a href=&#34;/shelley&#34;&gt;Shelley&lt;/a&gt; on that bot&#39;s VM and prompted his way to an incremental feature. So far, we have a Discord bot, a Slack bot, a link shortener, a query-my-logs agent, and a blog, all hosted on exe.dev, with no sign of slowing down.&lt;/p&gt;
</content>
    <author>
      <name>Josh Bleecher Snyder</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Goodbye Sketch, Hello Shelley!</title>
    <link href="https://blog.exe.dev/shelley" />
    <id>https://blog.exe.dev/shelley</id>
    <updated>2026-01-08T00:00:00Z</updated>
    <summary>Introducing Shelley, exe.dev&#39;s mobile-friendly, web-based, multi-modal coding agent.</summary>
    <content type="html">&lt;p&gt;Shelley is &lt;a href=&#34;https://exe.dev/&#34;&gt;exe.dev&lt;/a&gt;&#39;s coding agent. The name refers to the
Unix shell, since it&#39;s good at operating the shell tool, and, yes, it shares a
name with the poet Percy Bysshe Shelley.&lt;/p&gt;
&lt;p&gt;Shelley is open source. Check it out at &lt;a href=&#34;https://github.com/boldsoftware/shelley&#34;&gt;https://github.com/boldsoftware/shelley&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Our previous experience building the &lt;a href=&#34;https://sketch.dev/&#34;&gt;Sketch&lt;/a&gt; coding agent
influenced &lt;em&gt;exe.dev&lt;/em&gt; and Shelley significantly; this post both describes
Shelley and shares what we learned. Stop reading, though. Go to
&lt;a href=&#34;https://exe.dev/new&#34;&gt;https://exe.dev/new&lt;/a&gt; on your mobile phone and build
something. Go! Be gone!&lt;/p&gt;
&lt;div id=&#34;shelley-carousel&#34; style=&#34;max-width: 300px; margin: 2em auto; text-align: center;&#34;&gt;
&lt;img src=&#34;https://boldsoftware.github.io/public_html/shelley/mobile-1.png&#34; alt=&#34;Shelley on mobile&#34; style=&#34;width: 100%;&#34; /&gt;
&lt;div style=&#34;margin-top: 0.5em;&#34;&gt;
&lt;button onclick=&#34;shelleyPrev()&#34; style=&#34;padding: 0.3em 1em;&#34;&gt;← Prev&lt;/button&gt;
&lt;button id=&#34;shelley-pause&#34; onclick=&#34;shelleyToggle()&#34; style=&#34;padding: 0.3em 1em;&#34;&gt;Pause&lt;/button&gt;
&lt;button onclick=&#34;shelleyNext()&#34; style=&#34;padding: 0.3em 1em;&#34;&gt;Next →&lt;/button&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;script&gt;
(function() {
  var images = [
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-1.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-2.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-3.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-4.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-5.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-6.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-7.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-8.png&#34;,
    &#34;https://boldsoftware.github.io/public_html/shelley/mobile-9.png&#34;
  ];
  var idx = 0;
  var paused = false;
  var img = document.querySelector(&#34;#shelley-carousel img&#34;);
  var btn = document.getElementById(&#34;shelley-pause&#34;);
  var timer = setInterval(advance, 3000);
  function advance() {
    if (paused) return;
    idx = (idx &#43; 1) % images.length;
    img.src = images[idx];
  }
  window.shelleyNext = function() {
    idx = (idx &#43; 1) % images.length;
    img.src = images[idx];
  };
  window.shelleyPrev = function() {
    idx = (idx - 1 &#43; images.length) % images.length;
    img.src = images[idx];
  };
  window.shelleyToggle = function() {
    paused = !paused;
    btn.textContent = paused ? &#34;Play&#34; : &#34;Pause&#34;;
  };
})();
&lt;/script&gt;
&lt;p&gt;Shelley is a mobile-friendly, web-based, multi-conversation, multi-modal, multi-model, single-user coding agent built for, but not exclusive to, &lt;em&gt;exe.dev&lt;/em&gt;. It does not come with authorization or sandboxing: bring your own.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Mobile-friendly&lt;/em&gt; because ideas can come any time.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Web-based&lt;/em&gt; because terminal-based scrollback is punishment for shoplifting in some countries.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Multi-modal&lt;/em&gt; because screenshots, charts, and graphs are necessary, not to mention delightful.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Multi-model&lt;/em&gt; to benefit from all the innovation going on.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Single-user&lt;/em&gt;. Shelley runs on &lt;em&gt;your&lt;/em&gt; VM. This lets us put the agent right next to the systems it&#39;s working on.&lt;/p&gt;
&lt;h2&gt;Isolation &amp;amp; Lifetimes&lt;/h2&gt;
&lt;p&gt;Neither Sketch nor Shelley ask the user for permission. Instead, they
assume they are running in an appropriately sandboxed environment. For Sketch,
we used gVisor-based containers for our hosted solution and we used Docker if
you ran Sketch locally. We assumed your container would live exactly as long as
your conversation with the agent. This was a mistake. Imagine having IT wipe
your laptop clean every day? That&#39;s no way to live!&lt;/p&gt;
&lt;p&gt;With &lt;em&gt;exe.dev&lt;/em&gt;, I spin up a VM specific to a project, and I use and customize
that VM as my project evolves. Spinning up a new VM is only seconds away, but I
tend to prompt Shelley with &amp;quot;in a new worktree…&amp;quot;, and it works well, including
having many parallel conversations.&lt;/p&gt;
&lt;h2&gt;State storage&lt;/h2&gt;
&lt;p&gt;Shelley keeps its state in a sqlite database in &lt;code&gt;~/.config/shelley/shelley.db&lt;/code&gt;.
It&#39;s delightful. You can instruct Shelley to read its old conversations. You
can copy the file around if you need to. Users have had Shelley debug itself
with its database and sent bug reports. (Thank you!) I now think of my Shelley
history like my shell history (shout-out to Ctrl-G, the OG, and atuin, the new
generation)... I can always refer to it.&lt;/p&gt;
&lt;h2&gt;Mobile&lt;/h2&gt;
&lt;p&gt;With Shelley, I set out to be mobile-friendly from the get-go. This turns out
to be a clarifying constraint. You can&#39;t just place buttons willy-nilly if
you&#39;re dealing with a 16cm screen! Because &lt;em&gt;exe.dev&lt;/em&gt; VMs do not go to sleep,
and because they&#39;re big enough to do real work, you can check in on your agent
or kick off a new idea from your phone.&lt;/p&gt;
&lt;h2&gt;Web&lt;/h2&gt;
&lt;p&gt;As the Latin proverb says, &lt;em&gt;de gustibus non est disputandum&lt;/em&gt; (&amp;quot;about tastes, it
is not to be disputed&amp;quot;), but I vastly prefer the affordances of
the web GUI over terminal interfaces. Scroll up and down, look at pictures,
copy and paste. Maybe they were onto something over at Xerox PARC.&lt;/p&gt;
&lt;p&gt;The killer feature though is &lt;em&gt;exe.dev&lt;/em&gt;&#39;s proxy support, which was inspired by
Sketch&#39;s similar feature. When you ask Shelley to spin up a web server, you can
access it from your laptop or phone immediately, and test it out. I find that I
spend a lot of my time with coding agents doing the testing; Shelley and
&lt;em&gt;exe.dev&lt;/em&gt; conspire to make that easier. (Shelley also imported Sketch&#39;s code
review UI, based on Monaco diffs.)&lt;/p&gt;
&lt;img src=&#34;/assets/shelley-proxy.svg&#34; alt=&#34;Shelley proxy support&#34; style=&#34;max-width: 100%;&#34; /&gt;
&lt;h2&gt;Startup time&lt;/h2&gt;
&lt;p&gt;How fast you can get to your agent is important. This video is not sped up.
(Our VM creation is sometimes faster than Route53 DNS propagation; we&#39;re working
on it.)&lt;/p&gt;
&lt;div style=&#34;text-align: center;&#34;&gt;
&lt;video controls=&#34;controls&#34; autoplay=&#34;autoplay&#34; loop=&#34;loop&#34; muted=&#34;muted&#34; playsinline=&#34;playsinline&#34; style=&#34;max-width: 300px;&#34;&gt;
&lt;source src=&#34;https://boldsoftware.github.io/public_html/shelley/startup-demo.mp4&#34; type=&#34;video/mp4&#34; /&gt;
&lt;/video&gt;
&lt;/div&gt;
&lt;h2&gt;The Promise of Mutable Software &amp;amp; The Topology of Agents&lt;/h2&gt;
&lt;p&gt;If you&#39;ve built an internal tool, you know how useful and powerful it is, and,
inevitably, how painful making little changes to it is. By running the tool and
hosting the coding agent on the same VM, behind the same HTTP proxy, modifying
the tool is one click away.&lt;/p&gt;
&lt;p&gt;We&#39;ve done this, for example, for the Discord bot that promotes Discord
messages to bugs in our issue tracker and for the logs database agent that
helps us query our logs. These are conceived, built, and deployed on
&lt;em&gt;exe.dev&lt;/em&gt; and Shelley.&lt;/p&gt;
&lt;p&gt;For non-load-bearing internal tools, you can host and edit the tool in the same
place. You don&#39;t have to, but it works well.&lt;/p&gt;
&lt;img src=&#34;/assets/shelley-topology.svg&#34; alt=&#34;Shelley topology&#34; style=&#34;max-width: 100%;&#34; /&gt;
&lt;h2&gt;Hello Shelley!&lt;/h2&gt;
&lt;p&gt;Give Shelley a shout. We&#39;re over in the &lt;a href=&#34;https://exe.dev/docs/community&#34;&gt;&lt;em&gt;exe.dev&lt;/em&gt; Discord&lt;/a&gt; in the #shelley
channel; &lt;a href=&#34;https://github.com/boldsoftware/shelley&#34;&gt;here&#39;s our GitHub&lt;/a&gt;; give it
a spin. If you want to run it locally, that&#39;s fun too!&lt;/p&gt;
</content>
    <author>
      <name>Philip Zeyliger</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
  <entry>
    <title>Meet exe.dev, Modern VMs</title>
    <link href="https://blog.exe.dev/meet-exe.dev" />
    <id>https://blog.exe.dev/meet-exe.dev</id>
    <updated>2025-12-15T00:00:00Z</updated>
    <summary>Persistent, private, fast-starting VMs with automatic auth.</summary>
    <content type="html">&lt;p&gt;Today we are going public with the developer preview of &lt;a href=&#34;https://exe.dev&#34;&gt;exe.dev&lt;/a&gt;, a new VM hosting service. We will keep the service open for new users as long as our capacity lasts. Try it out with:&lt;/p&gt;
&lt;pre class=&#34;code&#34;&gt;&lt;code&gt;ssh exe.dev
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;As we built &lt;a href=&#34;https://sketch.dev&#34;&gt;sketch.dev&lt;/a&gt;, we found ourselves needing more machines than ever before. Whether using an LLM as a typing assistant or a sophisticated debugger, we found we had a lot more little software we wanted to run. Running it turned out to be the hassle. So we built a platform for making it easy.&lt;/p&gt;
&lt;p&gt;Notable features of exe.dev:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;All the VMs that fit&lt;/strong&gt;: your subscription gets you so much CPU and RAM. How your VMs share your resources is up to you. Want 20 idle VMs that answer an HTTP request every other day? Go for it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Real VMs, sub-second start&lt;/strong&gt; you get a full Ubuntu machine (or any other container image you decide to bring). Install Docker Compose if you like.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Persistent disks&lt;/strong&gt; with some really interesting work coming soon.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SSH-based API&lt;/strong&gt; get started by typing &lt;code&gt;ssh exe.dev&lt;/code&gt; and creating a VM.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Private by default, share with discord-style links&lt;/strong&gt; exe.dev takes care of TLS and auth for you. By default only you can reach your HTTP services, and you have easy mechanims to share them with friends and colleagues.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Agent-friendly sandbox&lt;/strong&gt; start a VM, ssh in, and use any agent you like. Treat the VM as a sandbox for maximum agent effectiveness.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt; &lt;/p&gt;
&lt;p&gt;Over the next few weeks we are going to be writing about all of the technology behind this. Each element is a significant project, but we waited until we had the whole package ready to try because we believe together they are more than the sum of their parts. Persistent, private, fast-starting VMs with no marginal cost per-VM is what cloud computing should like, and it only becomes clear when you put all the pieces together.&lt;/p&gt;
&lt;p&gt;You can explore the service right now with &lt;code&gt;ssh exe.dev&lt;/code&gt;.&lt;/p&gt;
</content>
    <author>
      <name>David Crawshaw</name>
      <email>support@exe.dev</email>
    </author>
  </entry>
  
</feed>
