The hyper-observable programming language

BAML is a programming language with built-in telemetry. Replace 10+ separate tools with one toolchain that helps agents test, trace, query data, build alerts, and more.

Get early access See how it works

CTSGo

BuildTestTraceDashboardsAlertsFeature flagsdeploy

baml checkbaml testbaml querybaml dashboardbaml alertsbaml flags

Each logo past deploy is a separate product with its own SDK.

deployProduction

BuildTestTraceDashboardsAlertsFeature flagsBeforeIn production

CC1972

Bring your own

TSTypeScript2012

tsc

GoGo2009

go build

go test

11 separate products

Separate products, each with its own SDK

baml checkbaml testbaml querybaml dashboardbaml alertsbaml flags

Used by engineers at

Iteration loops are fast when everything speaks the same language.

We didn't want to build a programming language.

But to make something 100x better, you have to vertically integrate. So we built BAML, with a virtual machine that makes it run anywhere,

one that allows us to profile every function at barely any cost,

a compiler that knows about your errors in production,

and a data lake to query your program data: profiles, spans, logs, traces, and blobs.

Raptor 1, Raptor 2, and Raptor 3 engines side by side, drawn as a blueprint. Each one has fewer external parts than the last.

Query traces, analyze errors, and improve your code, with one CLI.

Build

Designed for agents.

BAML is a fully open-source, completely free-to-use language.

1// Tools are ordinary functions.

2/// Look up a customer's plan and billing status.

3function lookup_customer(email: string) -> string {

4 `${email}: pro plan, paid through March`

7/// Search past tickets for ones like this one.

8function search_tickets(query: string) -> string[] {

9 ["Charged twice", "Wrong plan on invoice"]

10}

12// An agent is an AI function with tools.

13function support_agent(ticket: string) -> string {

14 client: "openai/gpt-6-luna"

15 tools: [classify, lookup_customer, search_tickets]

16 prompt: `

17 Answer this ticket. Look up the customer first.

18 ${ticket}

19 `

20}

1class Unroutable {

2 label: Label,

5// The match has to cover every Label, or baml check fails.

6function route(ticket: string) -> string {

7 match (classify(ticket)) {

8 "billing" => "support",

9 "bug" => "engineering",

10 "other" => throw Unroutable { label: "other" },

11 }

12}

14// The errors route can throw are part of its type.

15function handle(ticket: string) -> string {

16 route(ticket) catch (e) {

17 Unroutable => "triage-queue",

18 ai.errors.Failure => "retry-queue",

19 }

20}

1class Order {

2 id: int,

3 total: float,

6// Types are values at runtime. This lists a class's fields and their types.

7function fields_of<T>() -> string[] {

8 match (reflect.Type.of<T>().as_class()) {

9 let c: reflect.Class => {

10 c.fields().map((f) -> {

11 `${f.name}: ${f.type}`

12 })

13 },

14 null => [],

15 }

16}

18test "lists fields" {

19 assert.equal(fields_of<Order>(), ["id: int", "total: float"])

20}

1// A test sits in the same file as the code it tests.

2test "sarcasm is billing" {

3 assert.equal(classify("Oh great, charged twice again. Love that."), "billing")

6class Case {

7 ticket: string,

8 label: Label,

11// Load real tickets from S3 and make a test for each one.

12testset "production tickets" {

13 let s3 = S3Client { region: "us-east-1" };

14 let cases = s3.get_json<Case[]>("triage-evals", "cases.json");

15 for (let c in cases) {

16 test c.ticket {

17 assert.equal(classify(c.ticket), c.label)

18 }

19 }

20}

1// .feels() on anything, backed by Jev.

2function urgent() -> void {

3 let email = baml.io.input("email: ");

5 if (email.feels("urgent")) {

6 baml.io.println(email.ask("Draft a reply"));

7 }

10// ---- How it works: vibes.baml, in full ----

12// ─── Vibes: out-of-body judgment methods on *every* type ─────────────────────

13//

14// if (email.feels("urgent")) { ... } bool — Jev Noul, thresholded at 0.5

15// email.how("urgent") float — Jev Noul, raw probability

16// email.matches<Team>() T — Jev Choice: enum / literal union

17// email.judge<Mood>("What is the mood?") T — same, with an explicit question

18// ticket.fill<Triage>() T — class: one request, one question per field

19// email.ask("Draft a reply") string — generative model, for when you need text

20//

21// The blanket `implements<S> Vibes for S` below is what makes this work on

22// strings, ints, classes, arrays — anything. The value is serialized (strings

23// pass through, everything else becomes JSON) and handed to TypeSafe's Jev

24// classifier as the `state`. The *return type* of each method is the schema

25// Jev is asked to fill.

27interface Vibes {

28 /// Yes/no judgment. `true` when Jev's probability is >= 0.5.

29 function feels(self, quality: string) -> bool throws unknown;

30 /// Same question as `feels`, but you keep the probability and pick the threshold.

31 function how(self, quality: string) -> float throws unknown;

32 /// Pick one of T's members. T must be an enum, a literal union, or an

33 /// optional/union of those (`Team?`, `Team | "hold"`); a class is rejected

34 /// before any HTTP — use `fill<T>` for that. The question is T's `@@description`.

35 function matches<T>(self) -> T throws unknown;

36 /// `matches<T>` with an explicit question — required for literal unions,

37 /// which carry no `@@description` of their own.

38 function judge<T>(self, question: string) -> T throws unknown;

39 /// Fill every field of a class: one request, one question per field, one

40 /// typed value back. Field `@description`s are the questions.

41 function fill<T extends reflect.AnyClass>(self) -> T throws unknown;

42 /// Free-form generation about this value (not Jev — Jev only classifies).

43 function ask(self, instruction: string) -> string throws unknown;

44}

46implements<S> Vibes for S {

47 function feels(self, quality: string) -> bool {

48 Feels(state_of(self), quality)

49 }

50 function how(self, quality: string) -> float {

51 How(state_of(self), quality)

52 }

53 function matches<T>(self) -> T {

54 require_choice<T>();

55 Matches<T>(state_of(self))

56 }

57 function judge<T>(self, question: string) -> T {

58 require_choice<T>();

59 Judge<T>(state_of(self), question)

60 }

61 function fill<T extends reflect.AnyClass>(self) -> T {

62 Matches<T>(state_of(self))

63 }

64 function ask(self, instruction: string) -> string {

65 Ask(state_of(self), instruction)

66 }

67}

69/// `matches<T>` is for picking one of a finite set. Reject a class (or anything

70/// else that isn't an enum / literal / union of those) before making a request.

71function require_choice<T>() -> void {

72 let ty = reflect.Type.of<T>();

73 let ok = match (ty.kind()) {

74 let _e: reflect.enum.Type => true,

75 let _l: reflect.literal.Type => true,

76 let _u: reflect.union.Type => true,

77 _ => false,

78 };

79 if (!ok) {

80 throw baml.errors.InvalidArgument {

81 message: `matches<T> and judge<T> need an enum or union, got ${ty}. For a class, use fill<T>().`,

82 };

83 }

84}

86/// Strings go to the model verbatim; anything else is serialized as JSON.

87function state_of<S>(v: S) -> string {

88 match (v) {

89 let s: string => s,

90 _ => baml.json.to_string(v),

91 }

92}

94// ─── The LLM functions behind the methods ────────────────────────────────────

95// Jev is a classifier: the return type is the question shape, `role("instructions")`

96// is the question, everything else in the prompt is the `state` being judged.

98client Jev = typesafeai.Client.new(model = "jev-latest", api_key = env.TYPESAFE_API_KEY);

100function Feels(state: string, quality: string) -> bool {

101 client: Jev

102 prompt: `

103 ${role("instructions")}

104 Does this feel ${quality}?

105 ${role("user")}

106 ${state}

107 `

108}

109

110function How(state: string, quality: string) -> float {

111 client: Jev

112 prompt: `

113 ${role("instructions")}

114 Does this feel ${quality}?

115 ${role("user")}

116 ${state}

117 `

118}

119

120// No instructions: the question comes from T itself — an enum's @@description,

121// a class field's @description, etc.

122function Matches<T>(state: string) -> T {

123 client: Jev

124 prompt: `${state}`

125}

126

127function Judge<T>(state: string, question: string) -> T {

128 client: Jev

129 prompt: `

130 ${role("instructions")}

131 ${question}

132 ${role("user")}

133 ${state}

134 `

135}

136

137// Generation is not Jev's job — hand that to a regular model.

138client Writer = anthropic.Client.new(model = "claude-sonnet-5", api_key = env.ANTHROPIC_API_KEY);

139

140function Ask(state: string, instruction: string) -> string {

141 client: Writer

142 prompt: `

143 ${role("system")}

144 ${instruction}

145 Reply with only the result — no preamble.

146 ${role("user")}

147 ${state}

148 `

149}

syntax and readability of TypeScript
correctness and tooling of Rust
compile times and concurrency of Go
dynamism and nothing else of Python

Deploy

Turn your program data into a queryable data lake.

The BAML runtime records your program as it runs and sends it to Boundary Cloud. There's no SDK to install and no collector to run.

Get early access

Your app

AI calls

The provider, model, tokens, and cost of every AI call, next to its arguments and result.

gpt-6-luna1,204 tokens$0.0042

claude-sonnet-5-51,388 tokens$0.0061

Profiles

How long every function took. It costs so little that Boundary Cloud doesn't charge for it.

Errors

Where each error started and how it moved up the stack, without changing code.

ParseError in parse

at classifytriage.baml:14

at routetriage.baml:31

boundary cloud

A data lake hosted by us, in your cloud, or on your machine

Your terminal

$ baml query

SELECT span_name,

p95(duration)

FROM spans

GROUP BY span_name

classify1.2s

route6ms

Observe

Create dashboards and alerts from your traces.

Make custom dashboards that are 100% tied to your product by using the SQL-based query API.

Calls per minute

SELECT count(*) FROM spans GROUP BY minute

last 4 hours

Labels

SELECT output_value, count(*) FROM spans WHERE span_name = 'classify' GROUP BY hour, output_value

billingbugother

Latency by function

SELECT span_name, p50(duration), p95(duration) FROM spans GROUP BY span_name

route

p50 1.4s

p95 2.9s

classify

p50 1.3s

p95 2.4s

Share labelled other

SELECT avg(output_value = 'other') FROM spans WHERE span_name = 'classify' GROUP BY hour

alert firing on classify

ImproveComing soon

Roll out experiments 100x faster than your CI/CD runs.

The BAML runtime can track experiments and A/B test functions securely for you, without having to redeploy.

gpt-6-sol's share of classify's traffic, and what it cost

gpt-6-luna3.1% labelled other, $0.03 per 1k calls

gpt-6-sol0.3% labelled other, $0.65 per 1k calls

Use BAML where the feedback loop matters most.

BAML can be adopted incrementally. You can literally call BAML functions from Python.

Start migrating an AI agent or workflow.

Move one agent or workflow into BAML, and call it from the rest of your app.

# app/tickets.pyfrom baml_sdk import triagedef handle(ticket: Ticket) -> None:    # "billing", "bug", or "other"    label = triage.classify(ticket.body)    if label == "bug":        escalate(ticket)

Keep the rest of your stack.

BAML works alongside Python, TypeScript, Go, Rust, Java, Swift, and C++. baml generate writes a typed client, so your app calls BAML like its own code.

Or send your existing OTEL traces.

Send OpenTelemetry traces to Boundary to get started, and move code into BAML for richer traces and better DX.

Get access to the BAML stack.

The stack is in private beta. Book a 45-minute call with the founders, and we'll set you up.

Get early access