dist_agent_lang

A runtime programming language tooled with trust off-chain and on-chain controls for the agentic future.

DAL is a programming language where AI agents are native citizens. Spawn agents, give them skills, persist their memory, coordinate multi-agent workflows, and serve them over HTTP. Program applications using distributed integration with off-chain services, and on-chain contracts coexisting through a unified trust model. Try the IDE.

v1.0.XX Beta — Actively maintained. Test thoroughly before production use.

Quick start

# Install
cargo install --git https://github.com/okjason-source/dist_agent_lang.git dist_agent_lang --bin dal

# Create an agent project
mkdir my-agent && cd my-agent
dal init agent

# Start the agent server
dal agent serve

This gives you a running agent with persistent memory, an HTTP API, evolve context (conversation history), and the default skill set (development, creative, office, home). No configuration required — persistence is on by default.

Update to latest: Run the install command again, or clone the repo and run ./update.sh.

What makes DAL different

Agents are built-in, not bolted on

DAL is a language where agent::spawn, agent::coordinate, agent::communicate, and agent::evolve are first-class operations. Agent memory, tasks, messages, and skills persist across restarts by default.

// Spawn an agent, give it skills, serve it over HTTP
let config = agent::create_config("assistant", "ai", "office assistant");
let agent = agent::spawn(config);
agent::set_serve_agent(agent.agent_id);

Skills are user-owned and composable

Define custom skills in .skill.dal files. Your skills, your agents — no central registry, no marketplace dependency.

// .dal/office.skill.dal
skill "ms_office" {
  category "office"
  description "Use MS Office tools (Word, Excel, Outlook) via run or scripts."
  tools "run" "search"
}

Agents reference skills by name. The runtime resolves them at prompt-build time and tells the model what it can do.

Molds: reusable agent configurations

Molds are reusable agent configurations (.mold.dal) that define type, role, skills, capabilities, and lifecycle hooks. Built by users, owned by users. Future licensing via on-chain smart registry (dynamic NFTs).

dal agent create --mold ./expert.mold.dal MyExpert

Hybrid trust model

One language for both on-chain and off-chain. No context switching between Solidity and Python.

@trust("hybrid")
service PaymentService {
    fn process(user_id: string, amount: int) {
        let payment = payment::process(user_id, amount);
        let tx = chain::deploy(1, "PaymentRecord", {
            "user_id": user_id, "amount": amount
        });
    }
}

Persistent by default

Agent memory (key-value store), task queue, message bus, evolution data, registered skills, and the agent registry all survive restarts. File-backed (JSON) by default; SQLite available for higher throughput. Opt out with DAL_AGENT_RUNTIME_PERSIST=0.

Architecture

DAL is a Rust-hosted interpreted language with a tree-walking runtime. The interpreter executes .dal files directly via dal run. The runtime provides:

• Lexer + Parser producing a full AST
• Runtime engine with scope, closures, and module resolution
• 30-module standard library: agent, ai, chain, crypto, database, auth, cloud, iot, mobile, desktop, evolve, trust, oracle, and more
• HTTP server (axum-based) for serving agents with /message and /task endpoints
• Package registry for publishing and consuming DAL packages

Compile targets (blockchain, WASM, native) exist as transpilation/code-generation backends. The primary execution path is the interpreter.

Features

CLI

dal run program.dal          # Run a DAL program
dal agent serve              # Start agent HTTP server
dal agent serve --behavior agent.dal  # Serve with behavior script
dal agent create ai MyAgent  # Create an agent
dal init agent               # Initialize agent project
dal check program.dal        # Syntax check
dal fmt program.dal          # Format code
dal lint program.dal         # Lint code
dal test                     # Run tests
dal repl                     # Interactive REPL
dal new my_project           # Create new project
dal mold list                # List available molds

Documentation

Canonical documentation is the Markdown under docs/ on the main branch (browse on GitHub). That tree is the source of truth for prose docs; tools and models can fetch stable raw URLs (for example PUBLIC_DOCUMENTATION_INDEX.md).

• Browse in the browser: Documentation index on GitHub Pages
• LLM / agent entry point: llms.txt (same file as llms.txt in the repo root)

Getting started

• Quick Start — Up and running in 5 minutes
• Agent Setup and Usage — Project setup, CLI, HTTP server, DAL APIs, molds

Agents and skills

• Skills and Registry — Define custom skills, configure the registry, programmatic encouragement
• Persistent Agent Memory — Runtime persistence, backends, configuration
• Agent Capabilities — Capability definition, validation, and usage

Retrieval and editor integration

• Configuration — Environment variables for RAG (DAL_RAG, index paths, DAL_RAG_TOP_K), MCP bridge (DAL_AGENT_HTTP_BASE, dal mcp-bridge), and web search / HTTP fetch
• Agent setup and usage — RAG and MCP in practice (when to enable retrieval, wiring an IDE to your agent HTTP server)
• RAG MVP spec — Lexical retrieval into agent prompts (rag::prompt_block, include_rag, corpus indexing)
• IDE and agent integration — Mental model: agent over HTTP first; MCP as an optional stdio bridge for editors (Cursor, etc.); LSP for language tooling

Reference

• Complete Documentation Index — All docs in one place
• API Reference — Standard library documentation
• Mold Format — .mold.dal syntax and lifecycle
• AI Features Guide — AI capabilities and integration

Release: docs/RELEASE_DOCS_BUNDLE.md lists which docs to include with the language install so users and LLMs have access to the most important documentation.

Beta notice

Current version: v1.0.8 (Beta)

Ready for:

• Development and prototyping
• Learning and experimentation
• Non-critical applications
• Beta testing and validation

Use with caution for:

• Production financial applications (wait for v1.1.0+)
• High-value smart contracts (third-party audit recommended)
• Critical infrastructure (additional validation needed)

Contributing

We welcome contributions of all kinds.

• Test the language — Run examples, report bugs
• Improve documentation — Fix typos, clarify instructions
• Share feedback — Tell us what works and what doesn't
• Code — See CONTRIBUTING.md and GOOD_FIRST_ISSUES.md

Installation

From source

git clone https://github.com/okjason-source/dist_agent_lang.git
cd dist_agent_lang
cargo build --release
./target/release/dal --version

From binary

Download from GitHub Releases

From Cargo

cargo install --git https://github.com/okjason-source/dist_agent_lang.git dist_agent_lang --bin dal

Requirements: Rust 1.70+ (Install Rust)

Testing

cargo test                      # Run all tests
cargo test -- --nocapture       # With output
cargo test --test example_tests # Specific suite

140+ tests passing across all standard library modules.

Learn more

• Documentation — Complete documentation index
• Examples — 27+ example programs
• GitHub — Source code and issues
• Discord — Community

License

Apache License 2.0 — see LICENSE.

Made by OK Jason