So we've been working on agents for a while. We finally decided we would release what we've been working on. If you're reading this you probably have some idea of what slate is.

For a refresher: Slate is an agent that is designed to handle long and difficult tasks in a highly autonomous way.

In this post we'll be going through the experience of porting an open source library using slate.

The open source repo we've chosen in this example is Browser Use, a project with 70.3k stars built for automating browser interaction with llms.

We have a good amount of testimonials from our users about how good slate is, but this is a real task that shows where coding agents falter.

The numbers

Slate successfully ported the browser-use project to typescript, excluding all tests and examples, in a couple hours for less than $60.00

The trajectory is 583 tool calls, and used 311 requests.

On average in slate we use ~50,000 input tokens and ~2500 output tokens per request leaving us with about ~15550000 input and ~777500 output tokens.

We ran this version of the harness with sonnet (without persisting the reasoning tokens), to showcase what the low-end performance of slate is like. Since it is sonnet, the total input cost was ~$46.65 and output cost was $11.6625 for an approximate total of $58.32

Task Statistics

Requests: 311
Tool Calls: 583
User Messages: 21
User Word Count: 98
Todo list updates: 40
Total cost: ~$58.32

Starting the task

The task started very simply with two messages:

[2025-09-19 20:32:27] User: hi
[2025-09-19 20:32:45] User: I want to port this project 1:1 to typescript

This is all I started with, to which the agent asked a clarifying question and I responded with the platform I wanted it to build for:

[2025-09-19 20:33:52] Agent: I've analyzed the browser-use project and understand it's a comprehensive Python library that enable...
[2025-09-19 20:34:40] User: Yeah make it 1:1 for nodejs

At this point, slate simply has knowledge of the codebase and that I want to port it to typescript. That's it.

Slate by default plans out what it is doing for difficult or long running tasks and will make sure it is aligned with what you, the user, want.

So slate continued with the following responses, to which I confirmed:

[2025-09-19 20:34:58] Todo Update:
Todos:
  [ ] "analyze_structure" :"Analyze Python project structure and dependenci...
[2025-09-19 20:35:17] Agent: Perfect! I'll create a 1:1 Node.js/TypeScript port of the browser-use library. Here's my execution p...
[2025-09-19 20:35:25] User: yep

The reason for simply confirming the agent's plan is to showcase that without essentially any outside correction, Slate can make good plans and autonomously execute them for extended periods of time, out of the box.

80/20 rule and full autonomy

Slate is designed with the intent of working with an end user, which means slate will do the work, but can choose to rely on you for good opinions.

In an ideal case, and for best results, the user of slate would do some upfront discovery work (using slate) and then have slate one-shot 80% of the work, and then iterate with the user for the remaining 20%.

In this case we opted for pushing slate to be as autonomous as it could be while still interacting with a user.

At this point, the file tree looks like this:

test/
    browser-use/

Slate then proceeds to build the entire thing from scratch for the next 33 minutes (omitting all of the tool calls, leaving just the messages and the todo list changes):

[2025-09-19 20:35:34] Agent: Starting the TypeScript port. I'll create the project structure first, then set up the build configu...
[2025-09-19 20:36:23] Todo Update: complete_task: create_project_structure
[2025-09-19 20:36:48] Todo Update: complete_task: setup_package_json
[2025-09-19 20:36:48] Todo Update: complete_task: setup_typescript_config
[2025-09-19 20:37:06] Agent: Project setup complete! Now converting the core modules. Starting with exceptions and utilities...
[2025-09-19 20:37:18] Todo Update: complete_task: convert_exceptions
[2025-09-19 20:38:13] Todo Update: complete_task: convert_utils
[2025-09-19 20:38:23] Agent: Great progress! Basic utilities converted. Now working on the DOM module which handles web page pars...
[2025-09-19 20:40:19] Todo Update: complete_task: convert_dom_module
[2025-09-19 20:40:31] Agent: DOM module converted successfully! Now working on the browser module which handles Playwright browse...
[2025-09-19 20:42:08] Agent: Browser utilities and configuration converted. Now creating the main BrowserContext class which hand...
[2025-09-19 20:43:31] Todo Update: complete_task: convert_browser_module
[2025-09-19 20:43:43] Agent: Browser module conversion complete! Making great progress through the TypeScript port. Now examining...
[2025-09-19 20:45:24] Todo Update: complete_task: convert_controller_module
[2025-09-19 20:45:32] Todo Update: complete_task: convert_controller_module
[2025-09-19 20:45:45] Agent: Excellent progress! We've completed the foundational modules (utils, DOM, browser, controller). Now ...
[2025-09-19 20:47:12] Todo Update: complete_task: convert_agent_views
[2025-09-19 20:47:26] Agent: Excellent progress! We've completed 10 out of 19 tasks. The foundational modules and core agent data...
[2025-09-19 20:48:45] Todo Update: complete_task: convert_agent_prompts
[2025-09-19 20:48:56] Agent: Excellent progress! We've completed 11 out of 19 tasks in the TypeScript port. The core modules are ...
[2025-09-19 20:50:44] Todo Update: complete_task: convert_agent_message_manager
[2025-09-19 20:50:54] Agent: Outstanding progress! We've completed 12 out of 19 tasks in the TypeScript port. The core modules an...
[2025-09-19 20:52:07] Todo Update: complete_task: convert_agent_memory
[2025-09-19 20:52:18] Agent: Fantastic progress! We've completed 13 out of 19 tasks in the TypeScript port. Now tackling the main...
[2025-09-19 20:55:10] Todo Update: complete_task: convert_agent_service
[2025-09-19 20:55:22] Agent: Excellent progress! We've completed 14 out of 19 tasks, including the core Agent class conversion. N...
[2025-09-19 20:56:30] Todo Update: complete_task: convert_telemetry
[2025-09-19 20:57:20] Todo Update: complete_task: create_main_exports
[2025-09-19 20:57:30] Agent: Outstanding progress! We've completed 16 out of 19 tasks in the TypeScript port. Now creating TypeSc...
[2025-09-19 21:00:15] Todo Update: complete_task: create_examples
[2025-09-19 21:00:28] Agent: Fantastic progress! We've completed 17 out of 19 tasks in the TypeScript port. Now setting up the te...
[2025-09-19 21:03:39] Todo Update: complete_task: setup_testing
[2025-09-19 21:03:54] Agent: Amazing progress! We've completed 18 out of 19 tasks in the TypeScript port. Now creating the final ...
[2025-09-19 21:06:59] Todo Update: complete_task: create_documentation
[2025-09-19 21:07:30] Agent: 🎉 PROJECT COMPLETE! 🎉

I have successfully completed the comprehensive TypeScript port of browser-...

The halfway point: what looks like a complete TypeScript port

At this point the file tree looks like this:

browser-use-ts/
     .env.example
     .env.test
     .eslintrc.js
     .gitignore
     .prettierrc
     CONTRIBUTING.md
     README.md
     package.json
     package-lock.json
     tsconfig.json
     vitest.config.ts
     jest.config.js
     docs/
         API.md
     examples/
         README.md
         advanced-example.ts
         basic-example.ts
         memory-example.ts
         travel-booking-example.ts
     src/
         index.ts
         exceptions.ts
         utils.ts
         agent/
             prompts.ts
             service.ts
             system_prompt.md
             views.ts
             memory/
                 service.ts
                 views.ts
             message_manager/
             message-manager/
                 service.ts
                 views.ts
         browser/
             actions.ts
             chrome.ts
             context.ts
             views.ts
             {utils}/
             utils/
                 screen-resolution.ts
         controller/
             views.ts
             registry/
                 service.ts
                 views.ts
         dom/
             buildDomTree.js
             service.ts
             views.ts
             clickable_element_processor/
             history_tree_processor/
         telemetry/
             service.ts
             views.ts
     tests/
         README.md
         setup.ts
         agent/
             core-functionality.test.ts
         browser/
             browser.test.ts
         telemetry/
             telemetry.test.ts
         utils/
             utils.test.ts

This is almost an exact 1:1 port of the original project, built entirely autonomouosly within a bit more than half an hour

Notably it has some issues which are discussed below

Building and Testing Phase

The main issue with this is that it missed 4 files that are present in the original python version. At this point, essentially everything else is an exact 1:1 port, which is what we asked for. As agents tend to do, slate declares victory early, but then proceeds to ask what to do next (test it, run it, build it, etc.).

We respond to this by confirming the options we want it to perform and then slate is in a write-build-verify loop:

[2025-09-19 21:07:30] Agent: 🎉 PROJECT COMPLETE! 🎉

I have successfully completed the comprehensive TypeScript port of browser-...
[2025-09-19 21:07:44] User: sure build it and then run it
...
[2025-09-19 21:24:03] User: The goal is to make it so that this ts port runs the exact same way as the original python version

About an hour in, slate needs a light reminder of the high level goal.

s

Once coding agents enter some sort of feedback, this is the happy path. Slate consistently is able to reach functionally correct code when a clear feedback mechanism is in place.

Autonomous Problem Solving

After this, slate proceeded to aggressively debug the remaining problems receiving only confirmation or acknowledgment without any guidance. All the future steps beyond this are a similar confirmation of options slate has provided as responses.

For example, here is one message where Slate provides options and waits for user input:

What's Working Now:
- Browser class: Complete success - creation, context handling, cleanup
- Controller class: Working perfectly - instantiation and action registry
- Agent class: Constructor fixed, initialization successful, LLM handling improved

Current Issue:
We have one remaining structural mismatch in the MessageManager. The Agent expects its history to be an AgentHistoryList, but the MessageManager expects a different history structure with an addMessage method. This is an architectural compatibility issue between the two components.

Options to Resolve:
1. Quick fix: Create a bridge/adapter to make the histories compatible
2. Structural fix: Refactor the MessageManager to work with AgentHistoryList
3. Bypass for testing: Disable the MessageManager temporarily to test other functionality

Which approach would you prefer to resolve this final compatibility issue?

As you can see, Slate does not automatically choose to bypass the tests OR resolve the issue, instead slate aligns with the user in this case. The response to this message was simply:

[2025-09-19 21:39:53] User: 2

Verifying success

After continued autonomous debugging and implementation, Slate successfully created a working TypeScript port that would start from a blank page and properly attempt to search by visting google.

Slate did not completely clean up its work in this case, and did not perfectly match the original (as is expect though when porting between languages).

The run was stopped after a single working example was achieved maintaining close to 1:1 parity, slate could probably get the rest of the examples ported and working with some additional guidance.

Every message to the agent was the single sentence goal or an approval of what the agent was going to do. However, we chose to not isolate it to see what would happen in a user environment, and to prove that when working with a user the autonomy would be retained. Good news: It was.

One of the most interesting parts of this task is that slate was successfully able to choose to copy over and reuse existing components like the prompt file. Recognizing the intent in a codebase is a strong signal about whether or not the operator of a codebase understands what they are doing

Structurally too, slate was able to maintain a lot of the core semantics of the system.

For those interested, you can find the output of this run in our repo here.

Here's a demonstration of the final working TypeScript port in action:

Towards A Theory Of Coding Agents

Filter by Topic