Key Takeaways

  • Legora CTO Jacob Lauritzen structured the company's platform around Lists, a database primitive modeled after Linear and Notion, to avoid hardcoding individual legal workflows.
  • Inbound requests from Legora's Slackbot, Intake, convert into structured tickets that both human attorneys and autonomous agents read, update, and resolve.
  • Agents coordinate recursively: agents create lists, lists spin up new agents, and agents query list states to execute multi-step reviews.
  • Legora deploys legal engineers instead of software developers to assemble specialized products, such as litigation fact extractors, by pairing generative user interfaces directly with Lists.

Stop Hardcoding Workflows for Agents

Most enterprise AI products fail because founders build single-purpose vertical features. If a client needs contract redlining, the startup writes a contract redlining UI. When the client asks for litigation discovery or inbound client intake, the startup writes two more custom interfaces. The engineering team drowns in bespoke code that cannot scale across law firms.

Lauritzen chose the opposite route at Legora. Instead of shipping a fixed set of automated features, his team built Lists, a structured database modeled after Linear. As Lauritzen explains: “we have this lists thing which is like linear for you know that's the closest equivalent and so it will add it to a specific intake list and then lawyers and agents can go into lore and just be like okay these are the things that you know people are sending to us.” (play from 38:14)

By treating legal work as structured task records, Legora creates a single surface where human lawyers and software agents sit side by side. When an email or Slack ping hits their Intake bot, the system creates a ticket on a list. From there, human lawyers assign the task or software models pick it up automatically.

How Lists Turn Agents into a Swarm

The real failure mode of autonomous agent swarms is coordination. When founders connect autonomous agents together through chained chat prompts, the system becomes impossible to debug. Nobody knows where a task stalled, which agent modified a clause, or why an output failed.

Legora solves this by using Lists as an explicit state store and coordination canvas. Lauritzen puts it plainly: “just like you might coordinate bunch of coding agents with linear or some sort of task management tool. We can do it similarly with lists and so like agents can create lists and lists can create agents and agents can read lists. And so it's like the agent swarm comes alive.” (play from 39:39)

Because the list operates like a database with configurable triggers, state transitions drive agent behavior. When an intake agent writes a record, a secondary document-review agent can trigger automatically, read the record attachments, extract facts, and post a structured update back into the database. If an agent gets stuck, the state remains visible in the list, allowing a human attorney to take over the ticket without restarting the whole job.

Why Legal Engineers Build Products on Primitives

Software engineers are expensive, and they rarely understand the daily mechanics of drafting motions or reviewing leases. Legora addresses this bottleneck by separating the core primitive from product customization. Core engineers focus strictly on database performance, automations, and scaling the Lists primitive. Meanwhile, legal engineers, who are lawyers who know how to build, assemble customer-facing tools on top.

“You can basically build that on list with like your own generative UI and then you basically have a new product that some people are going to love,” (play from 40:28) Lauritzen explains. “And we can have a market place of just like a bunch of specialized products that we can scale super quickly cuz all of our legal engineers can just build new ones.” (play from 40:35)

This structure turns workflow creation into low-code assembly. A legal engineer can configure custom fields, attach triggers, spin up a task-specific user interface, and deliver a fact-extraction tool in days without pulling a systems engineer off core database infrastructure.

What to Do With This

Audit your multi-agent architecture this week. If your agents talk to each other through unstructured conversational context, strip out the chat threads and replace them with a central task board like a shared Postgres table or a Linear project. Force every agent to read ticket states, update status columns, and write artifacts to explicit records so humans can inspect and debug the workflow at every step.