It seems like everyone is building AI agents right now. As LLMs have become more capable and developers have connected models to tools, agents have emerged as a way to let LLMs do real work with less human intervention.
Imagine you're on the road to work and need a way to prioritize and respond to your emails before you get to the office. An LLM can easily do this task, but unless you prompt it with each email by hand, your LLM can't read your email and even then it can't respond to emails on your behalf or create calendar events based on their content.
In order to do that work, the LLM needs to have access to tools that give it control over your email inbox and calendar. Connecting an LLM to those tools is what transforms it into an agent.
Dedalus Labs builds the infrastructure to connect LLMs to tools, enabling you to build production-ready agents that help your users get things done.
How do we define agents?
At Dedalus, we think about agents as a simple equation:
Agents = Model(s) + Tool(s)
This equation is at the core of every agent you build. An agent is a collection of models and tools, which you can use to complete tasks.
The agent acts as the infrastructure layer for the product you build. You decide how to specify intents and give your agent a goal and autonomy across multiple steps while the agent decides how to execute on that intent and what tools to use.
Think back to the email example. You can connect your LLM to tools like an email client, a calendar, and a web search tool. Then you could have a conversation with a voice agent, allowing you to reply to emails, identify high value leads from inbound messages, and adding events to your calendar, all without taking your eyes off the road. The agent decides what sequence of actions it needs to take and the tools it needs to call, freeing you up to do other things.
Each part of the equation is essential. Remove the tools and you have a text generator. Remove the model and you have an automation script. The combination of a persistent goal, a reasoning engine, and the ability to act is what makes something an agent.
What agents are:
- Connected to tools so they can take actions, not just generate text.
- Software systems that use an LLM to decide what to do next to achieve a goal.
- Able to observe results and iterate (plan -> act -> check -> adjust).
- Designed to be repeatable and reliable, not just clever once.
What agents aren't:
- A single prompt or static "chat with your data" experience.
- Deterministic automation with no decision-making.
- A wrapper around an LLM that can only write, not act.
How do you give your agent tools?
To equip an agent with tools, you'll need to communicate what that tool is and how to use it. You can do this directly by defining tool schemas and giving the LLM direct access to the underlying code to run. However, this approach falls apart when you want to share those tools with other agents.
The more standardized approach is Model Context Protocol, or MCP. This protocol exposes tools available to your agent as endpoints on a server. The agent identifies the tools it wants to use and provides a formatted input, leaving the execution to the MCP server itself.
Dedalus Labs provides access to hosted MCP servers through our marketplace, giving your agent access to ready made tools that can search the web, read and send emails, and more. These tools are available as hosted endpoints called either by their external url or marketplace slug if you are building an agent with our SDK.
There are other ways to give your agents tools, but when you build on Dedalus you have access to hundreds of ready made tools that you can add in one line of code from the marketplace.
Ready to build your first agent? Get started with our agent SDK or connect tools from our marketplace to your platform of choice using external URLs.