AI tools are everywhere - except where you actually work

Today we're launching Delphi, a platform where everyone can build email-based AI agents. Think 'Gmail for agents.'

Over the past 12 months we worked with multiple clients on implementing AI agents for use cases as distinct as contracts, accounting, operations or logistics planning. Though widely different, those use cases had a repeatable theme: email. Email is where the work is done today. Email is where the data live. Email is the natural tool for everyone.

And so, instead of fancy UIs or UXs clients asked for email integrations. Naturally, as any startup would confidently promised to deliver them. How hard can it be after all?

Turns out, agents that email are harder than it looks. There are no solutions out of the box that are suited to building email-based AI agents. So, we ended up building one: Delphi. Delphi allows you to easily build email-based agents for your business. For example, you can spin up yourcompany_invoices@emaildelphi.com that automatically parses incoming bills, cross-checks them with contracts, and replies for approval.

Knowledge work = email work

McKinsey estimates that 28% of our work is just responding to emails. Many knowledge job tasks begin and end with an email thread.

Some knowledge work jobs are 90% email based - people take out info from one system, put it into another one, then take it out again and send it back.

Logistics dispatching is a good example. A client requesting delivery of goods will send an email to a logistics coordinator. This triggers a chain of actions – usually more email exchanges between the coordinator and other people internally. An order will get created in a system. Once an order is completed, the coordinator will take info out of the system and send it back to a client with an invoice attached. In many companies' email is the #1 tool for doing a given job. It is the database, the communication channel and the business logic handler. For some of our clients, email is so pervasive, that they will have dedicated employees to handle only 1 task: managing email threads.

Accounting is similarly email heavy. Receiving invoices, reviewing them and sending back for correction or comments is done by a mixture of email + spreadsheets. Few SaaS systems today touch those workflows.

Building agents with email is hard

As an ambitious startup when people asked for email integrations or email tools we promptly agreed. "Can we email the agent this contract update and have it respond with a list of all contract updates it has?". "Well of course you can!". But then we hit a wall.

It turns out: email is really hard. Agents in email are even harder.

First, there's a lack of tooling. There are countless API-based tools for writing and sending emails - but almost none for receiving them. We began with building Outlook API wrappers, AI-integrations to Outlook emails and eventually full email agents in Outlook. But it sucked, didn't scale and came with a lot of issues. Microsoft just being Microsoft was one of them.

So we decided to build our own infrastructure for emails - one that would be developer friendly and agent-first. It worked… until it didn't. The deeper we went, the clearer it became: building an AI agent for email is nothing like building one for chat.

In chat, you design clear rules. The UI tells people what they can or can't do. Logins determine who can have access. But email? Email is open. Anyone can write to you if they know your address. And humans use it in ways that are second nature to us: e.g. CC'ing people just to "keep them in the loop". In a chat you ask the agent when you want something from it. In emails, you need to build logic for when the agent should not respond.

Document handling is another challenge. In web-based UIs, you can specify when, where and what your users can upload. In emails however, people just send attachments. And we humans interpret attachments in different ways. You can send a 50 page PDF saying "FYI, this is the signed contract, let's store it for posteriority" or a 1-page invoice asking "is this conform to the contract or are they overcharging us?". In both cases you're just sending an attachment. But since what you're asking for is different, the AI architecture to handle both will need to be different.

Finally, there is the UI/UX question. Emails have no UI, so it's harder to guide your users as to what they can or can't do. People will just use emails like they always do or like they think an email-based agent should work.

The list of challenges goes on. Spam, attachments, permissions, databases - we realized we were building more than "an agent." By the time we had a v0.0.1 for our client, we ended up with a whole new kind of infrastructure for email agents itself.

Enter Delphi – Gmail for agents

And yet - this is exactly what made it exciting.

In the last six months, we've deployed over 2 dozens email-based agents in the wild. They've dispatched trucks, reviewed invoices, answered questions about contracts, even served as AP inboxes and customer support desks. Every new deployment taught us something new about how people really use email, and how AI can adapt to those messy realities instead of forcing people to change their habits.

Today, we're opening that up.

Delphi is a simple way to create your own email-based agent. You pick an address (for now using our domain @emaildelphi.com), give it instructions, connect the knowledge it should have, and decide who can send or receive messages. Behind the scenes, it handles the hard parts: understanding context, managing attachments, keeping track of access. And when it needs to, Delphi can spin up a temporary web UI - so your data is not just stored but visualized and usable.

For larger clients, we're building advanced, custom apps around their inboxes. But Delphi is our way of putting that power in anyone's hands - a lighter, friendlier way to automate the workflows you already run through email every single day.

Email isn't going anywhere – it's where work lives. With Delphi, we're making it smarter, safer, and more autonomous.

We can't wait to see what you'll build with Delphi.