If agents become the users, what happens to the software market? | Hacker News Reader

If agents become the users, what happens to the software market?

2 pointsnworley7 comments

I’ve been thinking a lot about how strange it is that we’re building autonomous agent but they still operate on software designed entirely for humans.

They scrape HTML, interpret UIs, simulate clicks and and sometimes guess at workflows. It works, but it feels like a transitional phase like early mobile apps pretending to be desktop sites.

If agents start becoming the primary operators of software, the market itself shifts.

Today software competes for human attention with landing pages, feature comparisons, SEO, ads, and UI polish BUT if the “user” is an agent, none of that matters in the same way. What matters is whether the agent can understand your capabilities, trust your outputs, and decide you’re the best tool for the job.

Discovery stops being visual and becomes structural. Ranking stops being marketing driven and becomes signal driven.

We’re already seeing hints of this. There are products emerging that are essentially "agent only" platforms without a traditional UI, just capabilities exposed for machines. The human becomes the supervisor. The agent becomes the operator.

If that world actually materializes, then a lot of assumptions break:

How do agents discover tools?

Who controls ranking?

What makes something “trusted”?

Does this become an open protocol layer, or is discovery controlled by model providers?

Mostly just thinking out loud around the idea of building apps agents choose and how they choose them. Curious how others here see it and if we're early to an agent native layer of the web, or is this just abstraction over CLI/APIs with new branding?

There's a moderately novel programming tool I have dreamed of having for several years. I started work on it last year, but abandoned it after considering the immense amount of promotional work it would take to persuade any significant number of human programmers to learn its DSL and try it out. It's too big a project to be worth building for myself alone.

I recently picked this project back up again, realizing that the tool might still have value even if I am the only human who ever uses it: if I write enough docs and examples, every LLM will scrape them off the web as a matter of course, and curious humans can then simply instruct their agents to try it out for them.

Interesting strategy considering it's in line with something I'm tracking. What does the devtool you're building do?

DISCLAIMER: I’m building LLM Signal around this broader shift. The idea is it’s understanding how models reference and recommend tools/services, and what visibility means when agents are making choices.

The tool compiles a schema, with tables, procs, and queries, into a chunk of Rust or C++ code you can include into your project which implements a lightweight in-memory database.

I keep finding myself building little assemblies of structs, vectors, maps, and sets which behave like tables and indexes[1]. Wouldn't it be nice, I keep thinking, if I could just declare the data and the queries I want, then let some tool compute an efficient implementation?

The tool is meant for situations where SQLite would be overkill. Serialization, migration, ALTER TABLE, and such are all out of scope. While you could probably use it as an app's central data store, its footprint is meant to be small enough that you might whip up a little schema to help implement a single module, or a single process, within a larger piece of software.

In theory an LLM coding agent should find the consistency & performance guarantees available with this approach as useful as a human would.

1) one example from a couple of years ago: https://github.com/risc0/zirgen/blob/main/zirgen/compiler/la...

If the current generation of software engineers only know how to code using AI, engineers that don't need it will be that much more valuable in the coming years.

I’m less focused on engineers using AI to code and more on agents being the “users” of software. Especially because you have agents doing all these tasks now (ie. OpenClaw and others). Even if engineers stay critical, if the end consumer shifts from human clicks to agent decisions, distribution and ranking mechanics change.

Would you agree or do you think this stays human driven long term?

Yes. Reputation and eval layers on top of MCP.

I think that's true but do you see MCP as enough of a discovery primitive on its own, or does it still lack a ranking/trust layer? My intuition is that capability exposure is only half the problem and the harder part is how agents evaluate and choose between multiple similar tools.

Take Supabase for example. It’s disproportionately recommended by LLMs when people ask for backend/database stacks. It can't be just because of it's capability since a lot of tools expose similar primitives. Something in the model’s training data, ecosystem visibility, or reinforcement layer is shaping that ranking.

If agents start choosing tools autonomously, the real leverage point isn’t just “can you describe your capabilities in MCP?” but “how does the agent decide you’re preferred over 5 near identical alternatives?”

Do you think that ranking layer sits inside the model providers, or if it becomes an external reputation network?

Reply on news.ycombinator.com