What if agents were built in?

The division of labor is changing

Every previous language generation optimized for a human at a keyboard. The next one has three participants with different strengths:

Astra is designed around that triangle. Each release strengthens the strategic layer another notch:

Delivery against each guarantee is scored on the progress tracker, currently 5 of 11 shipped, each backed by a passing test.

Who Astra is for

Astra is built first for people who orchestrate or review code that AI writes.

Astra is not aimed (yet) at kernel developers, hard real-time systems, or teams needing a mature ecosystem today, see the honest status below.

Astra vs. the alternatives for agent code

Every language in this table is excellent at what it was designed for. The comparison is scoped to one question: what should an agent generate?

Agent-native keywords

Four keywords are reserved and ratified (Bet 4). The design intent, syntax is illustrative and will evolve through an RFC process:

tool search_flights(from: str, to: str, date: str) -> Result<[Flight], ApiError> {
    // a tool is a typed, sandboxed capability;
    // its signature IS its schema, no JSON-schema drift
}

memory TripContext {
    budget: float,
    preferences: [str]        // typed, persistent agent state
}

agent TravelPlanner {
    tools: [search_flights],
    memory: TripContext,

    prompt plan = "Find flights within ${memory.budget}";
}

What the compiler can then guarantee, before anything runs:

• Tool contracts hold. A tool's parameter and return types are checked at every call site. The "function-calling schema" cannot drift from the implementation because they are the same thing.
• Memory is typed. Agent state isn't a dict of anything, reads and writes typecheck like struct access.
• Prompts are checked templates. A prompt interpolation referencing a missing memory field is a compile error, not a silent hallucination input.
• Subagent boundaries are contracts. An agent handing work to another agent is a typed call, the compiler verifies the whole delegation graph.

Alongside the keywords: an agent SDK (bindings for LLM providers) and a sandbox so tools execute with declared capabilities only.

What has to land first

These foundations come before the agent keywords.

v1.0 completes the arc

• GPU target (NVPTX): the third LLVM target: same language from orchestration script to kernel.
• Mifa registry (mifa.dev): checksummed, signed packages; the lockfile contract goes global.
• Production tooling: test/bench runners, docs generator, debugger support.

The five bets underneath

The vision isn't a mood board, it rests on five architecture decisions debated and ratified on 2026-07-02, each with recorded rationale, accepted costs, and first milestones (two of which have already shipped):

The full decision records, rationale, accepted costs, amendment process, live in the repository and publish with the source at v1.0-beta.

Strategic language, tactical speed

In A Philosophy of Software Design, John Ousterhout draws the line between tactical programming: getting something working as fast as possible, and strategic programming: investing in design so the system stays changeable. LLMs are the ultimate tactical programmers: they produce working-looking code at machine speed, with no stake in the design surviving next week.

Astra's position: when generation is free, the strategic layer must move into the language. Types, contracts, Result-based errors, deterministic builds, and (soon) typed agent primitives are the design investment, enforced by the compiler, not by discipline. The agent supplies tactical speed; the language supplies strategic structure; the human supervises intent. That's the modern programming paradigm Astra is built for.

This isn't just positioning, each strategic guarantee is tracked and tested like a feature (5 of 11 shipped), and the release plan maps every version to the guarantee it adds.