Renyi MCP server

Renyi is the scripting language of AI agents: the agent writes it, you review it at a glance, and the program can only do what it declares.

Why Renyi

Agents now write most of the code that runs on your behalf. The code they write in today's languages has to be read line by line, or run blind. Renyi is designed around that division of labour: the agent writes, the person reviews, and the language makes the review a glance.

its effects (needs filesystem.read("data"), network.http("api.example")), scoped to a path or a host, budgeted (at most 60 per minute) and guarded (only to). The compiler refuses what is not declared; the runtime admits only that, for the program's dependencies too. The signature of main is the whole program's grant.

1. What a program may do is in its signature. Every function declares

reproduced under its manifest (toolchain, code hash, dependencies, grant, arguments, outcome); --explain narrates it in the words the program's author wrote. You know what a run did, as data.

1. Every run is evidence. A run can be recorded, replayed offline and

computed from its sources, never written by hand; an update that would let the program do more is refused, not noticed later.

1. Dependencies cannot widen what you allowed. A package's effects are

semantic diff and the chunks for retrieval by embedding are commands (renyi index, --diff, --chunks), the toolchain is an MCP server (renyi mcp), documentation is syntax (purpose:), and every error carries a fix, so the agent's next attempt is right.

1. The tooling an agent needs is built in. The project map, the

concept, one canonical layout, no exceptions, no null, no anonymous functions, no operator overloading. A reviewer who has never seen Renyi reads what a program touches from its signature.

1. Read in one pass, by anyone. Regular English with one spelling per

public function active_adult_emails(path: Path)
  returns List of Email
  or fails with FileError or JsonError
  needs filesystem.read
  purpose: Read users from a JSON file and return the e-mails of active users who are at least 18.

  let text be filesystem.read_text(path) otherwise fail
  let users: List of User be json.parse(text) otherwise fail
  let emails be
    for each user in users
    where user.is_active and user.age is at least 18
    sorted by user.name
    collect user.email
  return emails
end

Renyi is a general-purpose language; its first users are people who run automation with Claude Code, Codex and their like, and will not run an agent's Python blind. The design record is docs/design/08-positioning.md (decisions AH1 to AH4).

Against the alternatives

Each row is a claim the implementation keeps and the conformance suite tests. The other languages were built for other jobs and do them well; the comparison is for one job, a program an agent wrote and a person must trust.

Shortened. The full README is on GitHub.