General intelligence in computing may emerge from multiple agents pursuing their own goals and interacting with one another.
2
MCP tool discovery lets agents find tools as needed, but agents still need a way to authenticate, subscribe to, and pay for external services.
3
A centralized MCP marketplace can wrap external APIs and nested MCP servers so agents access them through one account while creators monetize the services.
Summary
Jan Curn argues that intelligence can emerge from interactions among independent units, as it does in biological systems, markets, and companies. He expects a similar pattern in computing, where agents with separate goals communicate through MCP and form an agentic economy. Apify provides a marketplace of about 5,000 software tools called actors, and its MCP integration lets agents discover and call those actors when needed. Curn says tool discovery solves only part of the problem. Agents still need credentials and a way to purchase services without a human configuring every connection. His proposed answer is a centralized marketplace where creators wrap external APIs or publish nested MCP servers, add pricing, and handle payment to the underlying service. A demo shows an agent discovering tools for web research, Twitter scraping, and browser automation. Curn is open about unresolved issues, including flaky discovery and the difficulty of making agents trust unfamiliar tools.
General intelligence may emerge from interacting agents
Curn compares intelligence in biological systems with intelligence in markets and companies. Individual neurons, people, or employees pursue their own interests and learn to communicate, while their interaction produces behavior that is larger than any one unit. He applies the same idea to computing systems. Instead of expecting one increasingly large model to provide general intelligence, he thinks multiple models or agents could pursue separate goals, interact, and produce more capable collective behavior. MCP supplies what he calls the missing part: a way for agents to communicate and form an agentic mesh.
Apify is presented as a marketplace with about 5,000 tools called actors. The company began in web scraping, so many actors extract data from social media, search engines, and websites, while others process data. Each actor is a self-contained Docker-based software unit with defined inputs and outputs. Creators from the Apify community can publish actors and earn money from them. Because the units have clear interfaces, developers can call them through TypeScript and Python SDKs, OpenAPI, C, command-line tools, and workflow products such as Zapier and Clay.
Tool discovery prevents agents from loading every tool at once
Apify's MCP integration gives an agent access to its marketplace through an API key and one MCP server. The agent can discover and call any of the marketplace's actors. Curn says publishing all 5,000 tools through OpenAPI would make the context too large and increase the risk of poor results. With discovery, the client first connects to the MCP server, then finds tools based on the current workflow. He describes this as MCP's main difference from OpenAPI and says support was appearing in clients such as VS Code and Claude for Desktop.
Discovery does not give agents credentials or payment autonomy
Even when services support MCP, agents usually still need API tokens for each service. Curn uses Zapier as an example: its MCP access may expose thousands of apps, but a person still has to connect services such as GitHub or Slack. This leaves the agent dependent on the developer who configured its tools. He argues that an agent cannot operate independently if it cannot find a service and purchase access to it. The agent would otherwise need to create accounts, provide an email or phone number, handle subscription forms, and possibly solve CAPTCHA challenges.
A marketplace can provide a practical route to autonomous service access
Curn proposes a centralized marketplace of MCP services as an alternative to both direct agent subscriptions and a new universal identity and payments provider. A tool creator can supply an account and payment method for an external service, wrap its API or MCP server, set a price, and publish the result in the marketplace. The marketplace charges the user, pays the creator, and the creator pays the external service. This gives an agent one account and authentication path for many services. Curn also points out that MCP servers can be nested, with a parent server exposing actions from other MCP servers.
Dynamic discovery lets an agent add tools during a task
In the demo, Claude for Desktop has access to the Apify MCP server with a limited set of tools. When asked for the venue of AI Engineer World's Fair in San Francisco, it searches the actor marketplace, finds a web browser actor, and uses it to retrieve the answer. For a Twitter task, the required scraper is not initially in context. The agent searches the marketplace, calls an add-actor tool, refreshes its tool list, and then uses the newly available actor to find the conference account's latest tweet. Curn notes that the refresh required disabling and enabling a tool because of a client bug.
Nested MCP servers can expand the marketplace without the original provider's integration
Curn demonstrates another model with Browserbase. Apify created an account, added an API token, and published the service's MCP server on its own marketplace without requiring Browserbase to publish it there. The agent then uses the nested service to fill out an email subscription form on the conference website. The marketplace therefore can bring existing MCP servers into its ecosystem through a wrapper. Curn says this lets creators make tools or agents available to clients that already integrate with Apify, while the creator controls monetization.
The business model depends on discovery becoming reliable
Curn gives Apify's marketplace as evidence that creators can be paid for software tools. He says Apify paid more than $4 million to creators in the previous month, that actors generated more than $1.5 million per month overall, and that the ecosystem had one million monthly visitors. He is also clear about the limits. Dynamic discovery may be flaky, and it is already difficult to make agentic systems behave as expected even with fixed tools. He expects better models to make discovery more useful, but leaves open how agents will trust unfamiliar tools and one another, and whether this interaction can enable AGI.
"The general intelligence will actually emerge through interaction of multiple entities, can call them agents basically, like multiple models pursuing their own goals interacting with each other."02:14
Who should watch
You are building agents that need to discover tools beyond the small set configured by a developer.
Your product exposes an API or MCP server and you are considering marketplace distribution and usage-based monetization.
You want to understand the practical limits of agent autonomy, especially credentials, payments, tool discovery, and trust.
