Agents Without Training Wheels: The Model Agent

People aren’t directed by if statements and for loops, they’re given instructions and expected to get the job done. Why don’t agents work the same way?

Agents today exist at the app layer: LLM API calls duct taped together with a software framework. We believe this is an early phase in the cycle of AI agents, and soon agents will live closer to the metal at the model and runtime layer. The underlying large agent model will generate its next steps on the fly, use external tools, and follow its instructions to get the job done without a rigidly defined software workflow.

We think there will be two paradigms for building agents:

• Model-based agents at the model/runtime layer (aka Model Agents)
• Framework-based agents at the app layer (aka Framework Agents)

Both paradigms will coexist, but developers hate managing infrastructure and want better performance. Model agents fix both, and the LLMs available today are powerful enough but not distilled for this purpose. We’re a committed early believer: at our core Subconscious is a post-training company that turns existing LLMs into large agent models to enable intuitive, long-context agents.

What is a model agent?

A model agent is a system with workflow management burned into its driving AI model. Rather than defining the workflow steps with software, the agent can be given plaintext instructions (however specific) and generate its workflow decoded from the model layer as it reasons and takes action. A model agent requires a powerful agentic model and a runtime that allows for the model to use tools appropriately.

Model agents handle requests directly and generate their workflow steps. Framework agents rely on an underlying software framework.

Model agents are simpler to build, more flexible during runtime, and are much more efficient. Their main tradeoff is that you have to allow the model to generate its own workflow, and that might be uncomfortable for some use cases today. But there are many where this is suitable today (we’re most excited about search and Browser use), and that number will only grow over time.

Alone in the crowd

We divide the world today into two camps: the model-based agents (agent as a single inference call) and the framework based agents (LLM APIs + software).

Framework agents are the dominant paradigm today. Subconscious is pioneering model agents.

Today Subconscious is the only company publicly building in this direction, and we’re able to thanks to the capability and performance gains of our novel model runtime co-design. We’re proud to be the first, and we strongly believe more agents will be built this way in the future.

Back up. What’s so bad about framework agents?

Framework agents work well if your team needs extremely fine tuned control over a rigidly defined workflow, but the real world is much messier. True autonomy won’t be solved with this paradigm. More and more, companies and hackers are hitting the limitations of first-wave framework agents and face these fundamental problems:

• Lack of simplicity. There is no standard way to build an agent today. All are complex to build, require dedicated engineering for every edge case, and teams spend more time reinventing the wheel than actually building something meaningful. And once it’s running you have to maintain a ton of prompts and additional infrastructure.
• They’re bad at long contexts. Deep down a reasoning chain, agents experience context rot and fail. Agent frameworks leave the burden of solving these issues to engineering teams. No matter how powerful the underlying models get, building at the framework layer will require engineering teams to manage context. (See our thoughts on context rot)
• Expensive at scale. It’s extremely expensive to run agents for long periods of time due to costly round trips for tool calls and long context inputs. When you’re piecing together model calls intended for chat bots, this will always be the case.

Fundamentally, when you build an agent as software + language model APIs, you’re going to hit these limits even as the underlying models improve.

A world with model agents

With model agents, these core limitations get solved. They make true autonomous software viable for the first time, especially for messy real world challenges.

LLMs gave us magically generalizable software through an API call. Model agents take this a step further: long-running, tool-using software that feels like real AI.

We’re excited to pioneer this path with a focus on enabling vertical AI companies as core infrastructure. This is how companies will move from fragile prototypes to production systems that last, and we believe this shift will define the next decade of AI.

Try Subconscious and build your first model agent today.

Jack & Hongyin