Many minds.
One intent.

Keep AI-written code under control. Spend fewer tokens.

Agents now write code faster than anyone can review it, so the intent is the thing to keep. Juxt makes the program the source of truth and checks the repo against it. Questions about the program itself are answered without a model; whether Juxt saves tokens on real coding work is what the open benchmark below measures.

See it work inside the tools you already use.

Each film runs about 50 seconds and compares the same job with and without Juxt. They are animated mock-ups of the planned experience with illustrative numbers. The app windows are generic designs, not the real interfaces of Claude, Codex or any other product.

Not a mock-up. Real output.

The Juxt plugin running in Claude Code against a small test repo, unedited. It read the project's context file, inherited its rules, spotted the double-refund risk and asked three questions before writing any code.

Pick how the agents work. Keep the patterns you trust.

Choose an agentic pattern, then the design pattern your codebase already uses. Juxt finds that pattern in your repo, turns its rules into constraints, and the agents build inside it instead of inventing a new one.

Chat freely. Pay only for what's new.

Most chatbot traffic is repeated questions and routine reports, and each one burns a full model call. Juxt sends every request down a ladder and stops at the cheapest tier that can answer it correctly. The model writes a report program once; after that, the program runs on fresh data at zero tokens.

Use the tool's own expertise. Show the savings.

Claude Code, Codex and other agents ship commands, skills and subagents tuned for their models. Juxt discovers them at the start of a session and compiles each step to the native one, falling back to a generic step only when nothing fits. Every run leaves a receipt, so the value is visible to whoever pays.

Where the savings come from, scenario by scenario.

A cost model, not a measurement: every number comes from the assumptions in the table, so you can check the arithmetic or swap in your own. Measured results come only from the open benchmark, run with the agent's reported usage.

How Juxt compares, including where it doesn't win.

Spec-driven development is a crowded, healthy space. Here is where Juxt differs and where the others are ahead today. If one of them fits you better, use it.

Go deeper. Pick your path.

Meet Juxt, in a minute.

A calm, narrated introduction with an original guide character. From a prompt-and-hope to one written intent — objective, rules and the checks that prove it — then one program across every tool you already use.

Many minds. One intent.

The full hand-drawn story: six agents in tangled harnesses, one use juxt, a live PHP2Shell server patched after it asks and proved after it patches, then the language compiling into an agent → agent → agent pipeline. Plays silent.

Direct a team of AI agents in one readable program.

Juxt is a declarative language for directing AI agents. You state the outcome, the rules, the interface, the team and the proof. The runtime, whether a coding agent or the Juxt gateway, turns that into exactly the context each model needs, and nothing it doesn't.

41 words for directing AI agents. Every one with an example.

Status is honest. Works today means agents follow it in Juxt mode and the linter checks it. In the spec means it is defined in the language spec and agents follow it as instructions, without runtime enforcement yet. Roadmap is designed, not shipped.

Small enough to learn in an afternoon. Strict enough for agents.

One compiler. Every agent, every harness.

The compiler is zero-dependency JavaScript: a line lexer, a block parser that understands labels and two-word keywords, a checker for the static rules, and an intermediate representation (IR) that host adapters turn into skills, subagents or a prompt frame for any model.

Agents never see your whole repo. Each one sees its slice.

A Juxt run is a pipeline, not a chat. The tier router answers from recall or a compiled program when it can. When a model is needed, the context assembler builds one slice per agent, with rules first. The harness checks every tool call in code, and a fresh reviewer proves the result.

Agent to agent to agent. Across teams, vendors and companies.

The next wave of software is agents calling agents. Juxt makes every hop explicit: who is trusted, what each agent may see, what it hands on, how much it may spend, and how deep delegation can go. Remote agents speak the open A2A protocol with signed agent cards; tools speak MCP.

A whole team of agents, briefed in ~372 tokens.

The complete rate-limit program is about 372 tokens. Rules and the contract take the most space, because they matter most. Runtime blocks such as policy and limits are read by the harness, so they never have to be sent to a model at all.

Rules outrank the goal, in every agent.

Juxt cannot change a model's weights. It controls what each model reads, in what order, and how often, and it moves the hardest rules out of the prompt and into code. This map shows the priority the compiler gives each block and how strongly it appears at each stage.

New models, new agents, new protocols. The language adapts.

Agent tooling changes every month. A Juxt program describes intent, rules and proof, the parts that don't change, and names capabilities instead of products. Everything that does change lives in adapters around it, so your programs keep working as the agent world moves.

One npm package. Every stack, every agent.

The juxt-lang package is the compiler and the CLI: zero dependencies, Node 18 or newer, published with npm provenance. JavaScript imports it directly. Python, Rust and anything else call its JSON output today; native packages are on the roadmap.

Five layers of intent. Every keyword comes from engineering practice.

An architect can read a Juxt program cold. Context from C4, constraints from RFC 2119, contracts from design by contract, agents and handoffs from the multi-agent playbook.

The words of every serious spec, plus OPEN.

Models fill gaps with plausible guesses. OPEN turns each gap into a question. In 2.0 it can be routed to a person or to another agent.

Six ways agents work together. One line each.

Pick the shape that fits the job. Juxt checks the shape for you: parallel agents need disjoint scopes, every handoff needs a typed payload, every loop needs a limit.

When you want to see every token.

Assembly for agents. juxt render --ir compiles a program into the exact prompt each agent will receive, ordered for prompt caching, with token counts and cost before anything runs.

Unsafe agent systems fail before they run.

Works today as plain text. The CLI makes it a platform.

Paste any .juxt program into a capable model and it runs. The CLI turns it into a platform: the first seven tools ship in juxt-lang 0.6, the rest are the roadmap.

Inside Juxt: from one program to many agents.

How a program is compiled, how it talks to each model, how agents hand work to agents across trust boundaries, and where every token goes. The same reference appears on the Language page.

One compiler. Every agent, every harness.

The compiler is zero-dependency JavaScript: a line lexer, a block parser that understands labels and two-word keywords, a checker for the static rules, and an intermediate representation (IR) that host adapters turn into skills, subagents or a prompt frame for any model.

Agents never see your whole repo. Each one sees its slice.

A Juxt run is a pipeline, not a chat. The tier router answers from recall or a compiled program when it can. When a model is needed, the context assembler builds one slice per agent, with rules first. The harness checks every tool call in code, and a fresh reviewer proves the result.

Agent to agent to agent. Across teams, vendors and companies.

The next wave of software is agents calling agents. Juxt makes every hop explicit: who is trusted, what each agent may see, what it hands on, how much it may spend, and how deep delegation can go. Remote agents speak the open A2A protocol with signed agent cards; tools speak MCP.

A whole team of agents, briefed in ~372 tokens.

The complete rate-limit program is about 372 tokens. Rules and the contract take the most space, because they matter most. Runtime blocks such as policy and limits are read by the harness, so they never have to be sent to a model at all.

Rules outrank the goal, in every agent.

Juxt cannot change a model's weights. It controls what each model reads, in what order, and how often, and it moves the hardest rules out of the prompt and into code. This map shows the priority the compiler gives each block and how strongly it appears at each stage.

New models, new agents, new protocols. The language adapts.

Agent tooling changes every month. A Juxt program describes intent, rules and proof, the parts that don't change, and names capabilities instead of products. Everything that does change lives in adapters around it, so your programs keep working as the agent world moves.

Boundaries agents cannot cross.

Declare bounded contexts, who owns which data, and which dependencies are allowed. Every agent change is checked against it, so a fast agent can't quietly turn your services into a distributed monolith.

Enterprise patterns, enforced instead of documented.

The classic integration and resilience patterns your architects already use, plus ten new patterns for teams that build with agents. Applying a pattern adds its constraints and its checks, so a saga without compensation or an outbox that publishes inside the transaction fails lint.

Standards set once, inherited everywhere.

Context federation lets the platform team set org rules, domains add their own, and services add specifics. A MUST set above can never be weakened below.

The work nobody wants to do again, written once.

Every engineering org repeats the same jobs forever. In Juxt each one is a recipe with a trigger, so it runs when the event happens instead of when someone remembers.

Your stack, always current.

Declare the stack and how fresh it must stay. When a release or advisory lands, Juxt reads the release notes, applies the codemods, and rolls the upgrade across every service in waves, stopping the moment a check fails.

Record it once. Every audience gets its own view.

Commits, tests, deploys, ticket moves and incidents are already facts. Today people re-tell them five times: in Jira, at standup, in an email to their lead, in a leadership status and on a dashboard. Juxt records each fact once in a ledger, then compiles every update from it at the right altitude. Jira and dashboards cost nothing; a short narrative uses a small model and must cite its facts.

Eight real projects, from first command to result.

Pick a project. Each walks through the exact steps, the Juxt you'd write, and what the agents do. Steps advance on their own; click any step to jump.

Fewer rounds. Fewer tokens. Every edge case named.

The next "language" is intent, rules and checks.

Four movements in the market point the same way: people describe outcomes, agents write the code, and the durable artifact becomes the specification. Juxt is built to sit exactly there.

On top of the open agent stack, not instead of it.

MCP connects agents to tools and data. A2A connects agents to other agents, across teams and companies. Both are open standards hosted by the Linux Foundation. Juxt describes the work; the protocols carry it.

Ready for longer runs, more agents and stricter trust.

Talk to the person behind Juxt.

Juxt-lang is created by Amit N (Amit Nilajkar), a software architect working on large-scale systems and machine intelligence. Business enquiries (partnerships, enterprise pilots, investment, licensing, press and the book) go straight to Amit. Project support and automated mail go to the project inbox.

PHP2Shell: let your AI fix it, safely.

Two critical PHP flaws let attackers run code on web servers without logging in. Working exploits are public and exploitation attempts have been reported. Updating PHP is the only fix. One command has your AI agent find every PHP that serves your site, ask before it changes anything, then prove the fix worked.