The agent-optimized language for building modern applications.
import { query } from "std/db/postgres" import { enable_auth, get_user } from "std/auth" let db = connect(get_env("DATABASE_URL")) enable_auth(db, map { "google": oauth_discover("google") }) fn dashboard(req) { let user = get_user(req) ?? redirect("/login") let posts = query(db, "SELECT * FROM posts WHERE author_id = $1", [user["id"]]) return render("dashboard", map { "user": user, "posts": posts }) } get("/dashboard", dashboard) listen(8080)
Every major programming language was designed for humans writing code by hand. NTNT is designed for a world where agents write the code and humans define what it should do. The language gives agents structured ways to understand a codebase, verify their own work, and ship without pulling in external dependencies.
ntnt intent check gives a definitive pass/fail after every change. No guessing whether the implementation matches the spec — the agent writes code, runs the check, and knows immediately what’s right and what isn’t.
ntnt inspect returns structured JSON describing every function, route, and contract. ntnt validate returns parseable errors. Contracts on functions declare inputs and outputs as readable specs. An agent can understand the full codebase in a single call.
HTTP, databases, JSON, crypto, concurrency, jobs — all built in. No package manager, no dependency resolution, no version conflicts. Every tool call that would normally install packages is a potential failure point. NTNT eliminates all of them.
No package manager means no supply chain attacks. The attack surface that plagues npm, PyPI, and crates.io — typosquatting, dependency confusion, malicious postinstall scripts — simply doesn’t exist. Your application code is your code, not a tree of transitive dependencies you’ve never audited.
Describe what you want built. Your agent generates a readable intent spec alongside the code, and NTNT continuously verifies that the two match. The spec is the test suite, so requirements and implementation never drift apart.
From your prompt, agents create .intent files with features, scenarios, and a glossary of domain terms that map to executable checks.
Agents write the code and link it to requirements with @implements annotations, plus requires and ensures contracts for runtime enforcement.
Agents run ntnt intent check for instant pass/fail, iterate on failures, and deliver verified code. You review the readable intent spec — not test output.
NTNT v0.4.8 runs on a Rust runtime with async I/O and connection pooling. These are real benchmarks against 9 frameworks across 6 languages.
Benchmarked against 9 frameworks across 6 languages. Read the full report →
Contracts, pattern matching, generics, and a 404-function standard library. No package manager needed.
Write requirements in .intent files. Link code with @implements. Run ntnt intent check to verify they match. Full traceability from requirement to implementation. Learn more →
requires and ensures are built into the syntax. Agents read them as specs. Humans read them as docs. In HTTP routes, contract violations automatically return proper error responses.
ntnt inspect outputs structured JSON describing every function, route, and contract. ntnt validate returns machine-readable errors. AI agents understand your codebase in a single call.
Two independent axes: NTNT_LINT_MODE and NTNT_TYPE_MODE. Start untyped and add types incrementally. Configure per deployment via environment variables.
Full OAuth 2.0, OIDC discovery, JWT signing and verification, CSRF protection, session management, bcrypt password hashing, and TOTP — all in std/auth. Add Google or GitHub login in a few lines, not a few dependencies.
No package manager needed. The standard library covers HTTP, databases, JSON, CSV, file I/O, crypto, and concurrency out of the box.
HTTP servers automatically reload when you save. No restart needed. Edit your code, refresh the browser, see changes instantly.
Language-native job DSL with priority queues, cron scheduling, unique jobs, and dead letter handling. Memory, PostgreSQL, and Redis backends built in. Observe and manage with ntnt workers.
Spawn tasks, send messages through typed channels, and compose with select, parallel, and race. Built on Rust’s async runtime.
Technical deep-dives on agent-native development, type systems, and language design.
A user signs up and you need to send a welcome email. The email provider takes 800 milliseconds to respond, and the user is watching a loading...
Read more →When we started benchmarking ntnt against other web frameworks, the results were humbling. Our single-threaded interpreter was doing 118K req/sec on...
Read more →The question of how much a computer should know about your data before running your code has been debated for about as long as programming languages...
Read more →NTNT is open source and MIT licensed. The code, the issues, and the roadmap are all on GitHub.