Better Call TIM: Filling out forms with an agent

The more important a form is to our lives, the more painful it feels to fill it out.

When I applied for a student visa to come to MIT, I spent five hours filling out a personal information form and an interview appointment scheduling form. Years later when I tried to raise pre-seed funding for Subconscious, I spent many nights filling out cold pitch forms on investor websites (luckily one of them worked and became our first investor).

I remember a night in 2016 when I had to figure out confusing visa application questions by searching online and translating terms with early machine translation models. Today, we have advanced AI chatbots and deep research agents, so you’d think form filling might be a problem of the past. Life would be much better if AI filled out forms and we only needed to proofread.

There are tons of browser agents powered by the latest frontier LLMs, and I felt confident one would be able to power a generalized form filling agent. However, I realized quickly that forms are as awful for AI as they are for humans: they vary wildly in element styles, interaction logic, and bot detection. For AI systems that claim to do everything, they definitely can’t fill forms reliably.

The Challenges of AI Form Filling

There are seemingly infinite ways to design a form on the internet, so completing a single field can be a computationally intensive task that takes several thinking, acting and evaluation steps. Consider dealing with a dropdown list or selecting a date from a calendar element, the agent needs to click on buttons and observe the browser state multiple times. For the simplest dropdown list, the agent needs to use four tools to click → observe the options → click again → click to confirm.

Four steps doesn’t sound like a long-horizon task, but the cost is ridiculously high. With one of the browser agent providers I tested, the cost for each step with Claude-sonnet-4 is $0.05. Meaning that correctly select for one dropdown list costs $0.20, and finishing just five fields in a form costs at least $1. Even this is the very rare best case. The model runs into errors and repetitions all the time reflecting on its endless ReAct trace, and the price often takes off. I saw the model iterating 20 steps ($1) just to fill in my email address, and there are many cases that I’ve seen the model runs 30 steps without successfully handling a dropdown list. My credit card was bleeding without getting any of these job done.

The deficiencies of browser agents stem from the flexibility of web forms and the rigidity of the agent framework’s context engineering strategy. The high variance of form designs necessitates multiple rounds of trial and error to fill in each field, and frequent webpage updates disrupt the agent’s reasoning, even for frontier models.

It was a painful decision for me to give up on using frontier models provided by the headless browser platform I was using. After spending $50 on development, I still didn’t manage to get a single form handled correctly even once. If I can’t get a simple form filling task handled by the most hyped frontier LLMs, I don’t know what new technology I can trust.

TIM to the Rescue

So I did what any founder would do, and I replaced their browser agent with our own TIM Agent Engine to solve the problem. TIM is a recursive reasoning engine that automatically handles context compression and multi-hop tool use for long-horizon agent tasks. In our experiments, the TIM significantly outperforms the browser agent powered by frontier LLMs on several dimensions:

The improvements are introduced by the agent-native features of the TIM Engine

• Recursive self-healing: TIM is a recursive reasoning model that plans for high-level tasks, calls tools and handle edge cases in decomposed subtasks within one LLM inference call. When the LLM runs into exceptions, it reasons within a subtask with a shared working memory until the problem is fixed instead of repeatedly retrying in its valuable context window.
• Automatic context engineering: The TIM model automatically compresses its own context by pruning the subtasks of completed tasks. This lossless context pruning strategy introduces two benefits: 1. the model no longer suffers long-context efficiency and hallucination problem, and 2. the model follows its initial instructions better because the generation head is closer to its new inputs.
• Server-side tool calling: The inference runtime for the TIM engine, TIMRUN, handles tool calling and tool response interpretation. This makes agent development very easy, reduces agent loop latency, and eliminates redundant cost for cached tokens.

The capability of our TIM engine to fill out forms exceeded our own expectations. A few cool actions we found really impressive:

• When it encounters a weird dropdown list that cannot be opened up by clicking, it found using the text input tool can expand the options.
• Seeing an error message, the system scrolls up to fix problematic fields and then scroll down to submit the form.
• Automatically figures out the correct element ID for file uploads when the “upload” button isn’t the right element, which can be a technique to avoid bots.
• The model tries to scroll down to reveal hidden fields where other agents get confused if the submit button is available.

These features solve the key challenges of agentic form filling: tool diversity, web dynamics, and very inefficient long-horizon reasoning.

After this success in form filling, we’re build a purpose built agent for this use case. We don't want you or you company to spend time staring at forms.

In the near future, expect more news on model training and comprehensive evaluation results. Interested in the form filling product? Join the waitlist and stay updated!