A new programming language called MALDA entered the scene this month, and its pitch is specific: it treats AI agents and LLM calls as native language constructs rather than library imports you wire up by hand. The language ships with a reference manual, a desktop IDE, a web playground, and VS Code support via a language server.
MALDA stands for Multi Agent Language with Development Automation. The name maps directly to what the language does. "Multi Agent" refers to built-in support for orchestrating multiple AI agents. "Language" means it has its own syntax, runtime, and tooling. "Development" covers the full toolchain: interpreter, compiler, IDEs, and language server. "Automation" describes the recursive loop at the center of the project: coding agents can write MALDA code because the language ships an LLM language pack in its repository, and MALDA programs automate development work in turn.
Prompts as first-class constructs
The most distinctive feature is how MALDA handles LLM interactions. A prompt block defines a schema for the expected output, a system message, and a user message template. The language compiles this into a structured call that validates the model's response against the schema at runtime.
The syntax looks like this: you declare a schema with typed fields, write a prompt block that references it, and call the prompt like a function. Without the await keyword, the call returns a rendered template with no API key required, useful for testing. With await, it actually hits the model. The validate() function runs the same check that await would apply to the model's JSON response, so you can test schema compliance without spending API credits.
This is a meaningful design choice. Most languages that support LLM calls treat them as HTTP requests you construct manually. MALDA makes the schema explicit in the language syntax, which means the compiler and language server can reason about the structure of your prompts. It also means schema violations are caught at development time rather than at runtime when the model returns unexpected output.
The agent system
MALDA's agent model is built on the actor pattern. You create an agent with a name, role, instructions, and a client connection. The agent has a think() method that accepts a prompt and returns structured output. Tool definitions use a @Tool decorator, and the runtime handles tool call resolution automatically with parallel read-only execution enabled by default.
The language supports multi-agent orchestration, including hierarchical systems where agents coordinate with each other. For developers building automation workflows, this means you can define a pipeline of agents that pass context between each other without writing the plumbing yourself. The conversation management layer handles tool calls and maintains state across interactions.
When no client is specified, MALDA defaults to a local LLM. The reference implementation uses Qwen2.5-0.5B-Instruct, downloaded as a GGUF build from Hugging Face on first run. No API key is required for local inference. The language also supports OpenAI, OpenRouter, LMStudio, and OLLAMA clients, plus a LlamaCppClient for running any GGUF model locally.
Web and API features
MALDA includes a built-in HTTP server and a decorator-based routing system for REST APIs. The @PAGE and @AIPAGE decorators generate full-stack web applications with a MALDA backend and server-rendered UI. There is also an MCP server component that exposes MALDA functions as MCP tools, which is relevant for developers building systems that need to interoperate with other AI tool ecosystems.
The language also supports an actor model for concurrent programming, which maps naturally to the multi-agent use case. Actors communicate through message passing, and the runtime handles scheduling. For developers coming from languages with explicit threading or async/await patterns, the actor model provides a different concurrency primitive that avoids shared-state bugs by design.
The toolchain
MALDA ships with three development environments. The Desktop IDE is a Windows WPF application with syntax highlighting, IntelliSense, a full debugger with breakpoints, error diagnostics, a compiler for standalone executables, and built-in profiling. The Web IDE is a browser-based playground. VS Code integration provides cross-platform editing with a language server that gives you the same autocompletion and diagnostics across operating systems.
The compiler can produce standalone executables, and the profiling tools work in both interpreted and transpiled modes. The command-line profiler supports periodic file snapshots for long-running processes, which is useful for debugging agent loops that run for extended periods.
Who this is for
MALDA targets two audiences. The first is people learning programming, who get a language with built-in AI capabilities from day one instead of learning a traditional language and then bolting on LLM libraries. The second is developers building AI applications who want the agent orchestration and tool system baked into the language rather than assembled from framework dependencies.
The reference manual includes a learning path for beginners that covers variables, conditionals, loops, functions, and arrays before introducing prompts and agents. The AI-focused path starts with prompt blocks and builds toward full-stack web applications with agent backends. Both paths converge on the same language, which means a team can mix developers with different skill levels using the same codebase.
The project is available at amaldini.github.io/maldalang. The reference manual, example programs, and toolchain are all included in the repository.