A language for writing agents.

A programming language written for agents: types the compiler checks before deployment, and every effect, whether a model call, a tool, a wait or an approval, explicit in the code.

Book a demo Explore the Agent Builder

What the agent does is buried in how it runs.

An agent written in general-purpose code mixes two things: the work it's supposed to do and the machinery that gets the machine to do it. The people who own the work don't always read the machinery, and the people who read the machinery don't always know what the work was.

agent CustomerService do
  def run(input) do
    # —— returns over $1,000 need approval ——
    case call(:check_order, %{id: input.order}) do
      {:ok, %{return: v}} -> delegate(Manager, %{amount: v})
      {:error, e} -> call(:open_ticket, %{notes: "#{e.message}"})

agent Support do
  case call(:order) do
    {:return, _} -> :manager
    {:error, _} -> :ticket

Prompt or Matiq, the same agent.

You write the agent in Matiq or draw it in the Studio: flow, code and tests are views of the same artifact, and the canvas is the code.

The compiler checks the contract, and what changes in the declaration changes in the flow, with version, owner and policy from day one.

Why a language for agents.

When an agent is described in a language made for it, what it does stops being scattered across the code that runs it.

Readable

Whoever owns the agent can read what it does.

Separate intent

What the agent does, separate from how it runs.

Reviewable

Every change is text: diffable, reviewable, approvable.

Simple

Read by whoever answers for the rule.

Wrong before it gets expensive.

Types before deployment

Gradual types checked before deployment: a broken contract fails at compile time, not in production and not after the model has spent a token.

Explicit effects

Every model call, tool, wait or approval is written in the code, and each one is a replay boundary.

Native decimal

Money here is not a float: monetary values use the language's own decimal type.

Read by compliance

A journey is short enough for the rule's owner to read. That is what makes review real instead of theatrical.

Why our team loves Matiq.

Because it grew out of a story we admire: a programmer who, in the 1950s, decided the machine had to understand the person describing the work, not the other way around. Matiq brings that idea to agents.

We're here to change how agents are written: less machinery for the people who build them, more clarity for the people who answer for them.